| /* Copyright (c) 2008-2010, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| // This file is part of ThreadSanitizer, a dynamic data race detector. |
| // Author: Konstantin Serebryany. |
| // |
| // Some libc functions are implemented in a way unfriendly to race detectors |
| // and memcheck-like tools. |
| // E.g. strlen() may read up to 7 bytes past the allocated buffer. |
| // To avoid false positives in these functions, the tool needs to replace these |
| // funcions with simpler implementation. |
| // |
| // The includer must define these macros: |
| // REPORT_WRITE_RANGE, REPORT_READ_RANGE, EXTRA_REPLACE_PARAMS, |
| // EXTRA_REPLACE_ARGS, NOINLINE |
| // See ts_valgrind_intercepts.c and ts_pin.cc. |
| |
| #ifndef TS_REPLACE_H_ |
| #define TS_REPLACE_H_ |
| |
| static NOINLINE char *Replace_memchr(EXTRA_REPLACE_PARAMS const char *s, |
| int c, size_t n) { |
| size_t i; |
| char *ret = 0; |
| for (i = 0; i < n; i++) { |
| if (s[i] == (char)c) { |
| ret = (char*)(&s[i]); |
| break; |
| } |
| } |
| REPORT_READ_RANGE(s, ret ? i + 1 : n); |
| return ret; |
| } |
| |
| static NOINLINE char *Replace_strchr(EXTRA_REPLACE_PARAMS const char *s, |
| int c) { |
| size_t i; |
| char *ret = 0; |
| for (i = 0; ; i++) { |
| if (s[i] == (char)c) { |
| ret = (char*)(&s[i]); |
| break; |
| } |
| if (s[i] == 0) break; |
| } |
| REPORT_READ_RANGE(s, i + 1); |
| return ret; |
| } |
| |
| static NOINLINE char *Replace_strchrnul(EXTRA_REPLACE_PARAMS const char *s, |
| int c) { |
| size_t i; |
| char *ret; |
| for (i = 0; ; i++) { |
| if (s[i] == (char)c || s[i] == 0) { |
| ret = (char*)(&s[i]); |
| break; |
| } |
| } |
| REPORT_READ_RANGE(s, i + 1); |
| return ret; |
| } |
| |
| static NOINLINE char *Replace_strrchr(EXTRA_REPLACE_PARAMS const char *s, |
| int c) { |
| char* ret = 0; |
| size_t i; |
| for (i = 0; ; i++) { |
| if (s[i] == (char)c) { |
| ret = (char*)&s[i]; |
| } |
| if (s[i] == 0) break; |
| } |
| REPORT_READ_RANGE(s, i + 1); |
| return ret; |
| } |
| |
| static NOINLINE size_t Replace_strlen(EXTRA_REPLACE_PARAMS const char *s) { |
| size_t i = 0; |
| for (i = 0; s[i]; i++) { |
| } |
| REPORT_READ_RANGE(s, i + 1); |
| return i; |
| } |
| |
| static NOINLINE char *Replace_memcpy(EXTRA_REPLACE_PARAMS char *dst, |
| const char *src, size_t len) { |
| size_t i; |
| for (i = 0; i < len; i++) { |
| dst[i] = src[i]; |
| } |
| REPORT_READ_RANGE(src, i); |
| REPORT_WRITE_RANGE(dst, i); |
| return dst; |
| } |
| |
| static NOINLINE char *Replace_memmove(EXTRA_REPLACE_PARAMS char *dst, |
| const char *src, size_t len) { |
| |
| size_t i; |
| if (dst < src) { |
| for (i = 0; i < len; i++) { |
| dst[i] = src[i]; |
| } |
| } else { |
| for (i = 0; i < len; i++) { |
| dst[len - i - 1] = src[len - i - 1]; |
| } |
| } |
| REPORT_READ_RANGE(src, i); |
| REPORT_WRITE_RANGE(dst, i); |
| return dst; |
| } |
| |
| static NOINLINE int Replace_memcmp(EXTRA_REPLACE_PARAMS const unsigned char *s1, |
| const unsigned char *s2, size_t len) { |
| size_t i; |
| int res = 0; |
| for (i = 0; i < len; i++) { |
| if (s1[i] != s2[i]) { |
| res = (int)s1[i] - (int)s2[i]; |
| break; |
| } |
| } |
| REPORT_READ_RANGE(s1, min(i + 1, len)); |
| REPORT_READ_RANGE(s2, min(i + 1, len)); |
| return res; |
| } |
| |
| static NOINLINE char *Replace_strcpy(EXTRA_REPLACE_PARAMS char *dst, |
| const char *src) { |
| size_t i; |
| for (i = 0; src[i]; i++) { |
| dst[i] = src[i]; |
| } |
| dst[i] = 0; |
| REPORT_READ_RANGE(src, i + 1); |
| REPORT_WRITE_RANGE(dst, i + 1); |
| return dst; |
| } |
| |
| static NOINLINE char *Replace_stpcpy(EXTRA_REPLACE_PARAMS char *dst, |
| const char *src) { |
| size_t i; |
| for (i = 0; src[i]; i++) { |
| dst[i] = src[i]; |
| } |
| dst[i] = 0; |
| REPORT_READ_RANGE(src, i + 1); |
| REPORT_WRITE_RANGE(dst, i + 1); |
| return dst + i; |
| } |
| |
| static NOINLINE char *Replace_strncpy(EXTRA_REPLACE_PARAMS char *dst, |
| const char *src, size_t n) { |
| size_t i; |
| for (i = 0; i < n; i++) { |
| dst[i] = src[i]; |
| if (src[i] == 0) break; |
| } |
| REPORT_READ_RANGE(src, min(i + 1, n)); |
| while (i < n) { |
| dst[i] = 0; |
| i++; |
| } |
| REPORT_WRITE_RANGE(dst, n); |
| return dst; |
| } |
| |
| |
| static NOINLINE int Replace_strcmp(EXTRA_REPLACE_PARAMS const char *s1, |
| const char *s2) { |
| unsigned char c1; |
| unsigned char c2; |
| size_t i; |
| for (i = 0; ; i++) { |
| c1 = (unsigned char)s1[i]; |
| c2 = (unsigned char)s2[i]; |
| if (c1 != c2) break; |
| if (c1 == 0) break; |
| } |
| REPORT_READ_RANGE(s1, i+1); |
| REPORT_READ_RANGE(s2, i+1); |
| if (c1 < c2) return -1; |
| if (c1 > c2) return 1; |
| return 0; |
| } |
| |
| static NOINLINE int Replace_strncmp(EXTRA_REPLACE_PARAMS const char *s1, |
| const char *s2, size_t n) { |
| unsigned char c1 = 0; |
| unsigned char c2 = 0; |
| size_t i; |
| for (i = 0; i < n; i++) { |
| c1 = (unsigned char)s1[i]; |
| c2 = (unsigned char)s2[i]; |
| if (c1 != c2) break; |
| if (c1 == 0) break; |
| } |
| REPORT_READ_RANGE(s1, min(i + 1, n)); |
| REPORT_READ_RANGE(s2, min(i + 1, n)); |
| if (c1 < c2) return -1; |
| if (c1 > c2) return 1; |
| return 0; |
| } |
| |
| static NOINLINE char *Replace_strcat(EXTRA_REPLACE_PARAMS char *dest, |
| const char *src) { |
| size_t dest_len = Replace_strlen(EXTRA_REPLACE_ARGS dest); |
| Replace_strcpy(EXTRA_REPLACE_ARGS dest + dest_len, src); |
| return dest; |
| } |
| |
| #if defined(TS_VALGRIND) |
| // Read every byte in the memory range. |
| static NOINLINE void ReadMemory(const void* p, size_t size) { |
| const volatile char* start = (const volatile char*)p; |
| const volatile char* end = start + size; |
| volatile char tmp = 0; |
| for (; start < end; ++start) { |
| // If we just read the bytes, Valgrind will optimize it out. |
| tmp ^= *start; |
| } |
| } |
| |
| // Read every byte in the null-terminated string. |
| static NOINLINE void ReadString(const char* s) { |
| const volatile char* p = (const volatile char*)s; |
| volatile char tmp = 0; |
| char c; |
| for (; (c = *p); ++p) { |
| tmp ^= c; |
| } |
| } |
| #endif // TS_VALGRIND |
| |
| #endif // TS_REPLACE_H_ |