tsan/ts_replace.h

/* 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_