[llvm-commits] [compiler-rt] r164022 - in /compiler-rt/trunk/lib/tsan: ./ lit_tests/ lit_tests/Unit/ rtl_tests/ tests/ tests/rtl/ tests/unit/ unit_tests/

Alexey Samsonov samsonov at google.com
Tue Sep 18 01:57:01 PDT 2012


Yeah, taking the address of main doesn't conform to standard anyway.
I've submitted a fix for this in r164115.
Sorry!

On Tue, Sep 18, 2012 at 1:05 AM, David Blaikie <dblaikie at gmail.com> wrote:

> On Mon, Sep 17, 2012 at 3:02 AM, Alexey Samsonov <samsonov at google.com>
> wrote:
> > Author: samsonov
> > Date: Mon Sep 17 05:02:17 2012
> > New Revision: 164022
> >
> > URL: http://llvm.org/viewvc/llvm-project?rev=164022&view=rev
> > Log:
> > [TSan] move: rtl_tests->tests/rtl unit_tests->tests/unit to make a
> single root for gtest-based tests. Support running these tests from lit via
> check-tsan command.
> >
> > Added:
> >     compiler-rt/trunk/lib/tsan/lit_tests/
> >     compiler-rt/trunk/lib/tsan/lit_tests/CMakeLists.txt
> >     compiler-rt/trunk/lib/tsan/lit_tests/Unit/
> >     compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.cfg
> >     compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.site.cfg.in
> >     compiler-rt/trunk/lib/tsan/tests/
> >     compiler-rt/trunk/lib/tsan/tests/CMakeLists.txt
> >     compiler-rt/trunk/lib/tsan/tests/rtl/
> >     compiler-rt/trunk/lib/tsan/tests/rtl/CMakeLists.txt
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_bench.cc
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mop.cc
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mutex.cc
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_posix.cc
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_string.cc
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util.h
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util_linux.cc
> >     compiler-rt/trunk/lib/tsan/tests/rtl/tsan_thread.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/
> >     compiler-rt/trunk/lib/tsan/tests/unit/CMakeLists.txt
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_clock_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_flags_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_mman_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_mutex_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_platform_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_printf_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_shadow_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_stack_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_suppressions_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_sync_test.cc
> >     compiler-rt/trunk/lib/tsan/tests/unit/tsan_vector_test.cc
> > Removed:
> >     compiler-rt/trunk/lib/tsan/rtl_tests/CMakeLists.txt
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_bench.cc
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mop.cc
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mutex.cc
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_posix.cc
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_string.cc
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test.cc
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util.h
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util_linux.cc
> >     compiler-rt/trunk/lib/tsan/rtl_tests/tsan_thread.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/CMakeLists.txt
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_clock_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_flags_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_mman_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_mutex_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_platform_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_printf_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_shadow_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_stack_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_suppressions_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_sync_test.cc
> >     compiler-rt/trunk/lib/tsan/unit_tests/tsan_vector_test.cc
> > Modified:
> >     compiler-rt/trunk/lib/tsan/CMakeLists.txt
> >     compiler-rt/trunk/lib/tsan/Makefile.old
> >
> > Modified: compiler-rt/trunk/lib/tsan/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/CMakeLists.txt?rev=164022&r1=164021&r2=164022&view=diff
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/CMakeLists.txt (original)
> > +++ compiler-rt/trunk/lib/tsan/CMakeLists.txt Mon Sep 17 05:02:17 2012
> > @@ -17,31 +17,6 @@
> >  add_subdirectory(rtl)
> >
> >  if(LLVM_INCLUDE_TESTS)
> > -  add_custom_target(TsanUnitTests)
> > -  set_target_properties(TsanUnitTests PROPERTIES
> > -    FOLDER "TSan unittests")
> > -
> > -  function(add_tsan_unittest testname)
> > -    # Build unit tests only on 64-bit Linux.
> > -    if(UNIX AND NOT APPLE
> > -            AND CAN_TARGET_X86_64
> > -            AND CMAKE_SIZEOF_VOID_P EQUAL 8
> > -            AND NOT LLVM_BUILD_32_BITS)
> > -      add_unittest(TsanUnitTests ${testname} ${ARGN})
> > -      # Link with TSan runtime.
> > -      target_link_libraries(${testname} clang_rt.tsan-x86_64)
> > -      # Build tests with PIE and debug info.
> > -      set_property(TARGET ${testname} APPEND_STRING
> > -        PROPERTY COMPILE_FLAGS " -fPIE -g")
> > -      set_property(TARGET ${testname} APPEND_STRING
> > -        PROPERTY LINK_FLAGS " -pie")
> > -    endif()
> > -  endfunction()
> > -
> > -  include_directories(rtl)
> > -  # There are two groups of unit tests: rtl_tests and unit_tests.
> > -  add_subdirectory(rtl_tests)
> > -  add_subdirectory(unit_tests)
> > +  add_subdirectory(tests)
> >  endif()
> > -
> > -# FIXME: Support TSan runtime tests, unit tests and output tests.
> > +add_subdirectory(lit_tests)
> >
> > Modified: compiler-rt/trunk/lib/tsan/Makefile.old
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/Makefile.old?rev=164022&r1=164021&r2=164022&view=diff
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/Makefile.old (original)
> > +++ compiler-rt/trunk/lib/tsan/Makefile.old Mon Sep 17 05:02:17 2012
> > @@ -19,9 +19,9 @@
> >
> >  SANITIZER_COMMON_TESTS_SRC=$(wildcard
> ../sanitizer_common/tests/*_test.cc)
> >  SANITIZER_COMMON_TESTS_OBJ=$(patsubst
> %.cc,%.o,$(SANITIZER_COMMON_TESTS_SRC))
> > -RTL_TEST_SRC=$(wildcard rtl_tests/*.cc)
> > +RTL_TEST_SRC=$(wildcard tests/rtl/*.cc)
> >  RTL_TEST_OBJ=$(patsubst %.cc,%.o,$(RTL_TEST_SRC))
> > -UNIT_TEST_SRC=$(wildcard unit_tests/*_test.cc)
> > +UNIT_TEST_SRC=$(wildcard tests/unit/*_test.cc)
> >  UNIT_TEST_OBJ=$(patsubst %.cc,%.o,$(UNIT_TEST_SRC))
> >  UNIT_TEST_HDR=$(wildcard rtl/*.h) $(wildcard ../sanitizer_common/*.h)
> >
> >
> > Added: compiler-rt/trunk/lib/tsan/lit_tests/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/lit_tests/CMakeLists.txt?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/lit_tests/CMakeLists.txt (added)
> > +++ compiler-rt/trunk/lib/tsan/lit_tests/CMakeLists.txt Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,12 @@
> > +configure_lit_site_cfg(
> > +  ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
> > +  ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
> > +  )
> > +
> > +# Run TSan unit tests.
> > +if(LLVM_INCLUDE_TESTS)
> > +  add_lit_testsuite(check-tsan "Running ThreadSanitizer tests"
> > +    ${CMAKE_CURRENT_BINARY_DIR}/Unit
> > +    DEPENDS TsanUnitTests)
> > +  set_target_properties(check-tsan PROPERTIES FOLDER "TSan unittests")
> > +endif()
> >
> > Added: compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.cfg
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.cfg?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.cfg (added)
> > +++ compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.cfg Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,29 @@
> > +# -*- Python -*-
> > +
> > +import os
> > +
> > +def get_required_attr(config, attr_name):
> > +  attr_value = getattr(config, attr_name, None)
> > +  if not attr_value:
> > +    lit.fatal("No attribute %r in test configuration! You may need to
> run "
> > +              "tests from your build directory or add this attribute "
> > +              "to lit.site.cfg " % attr_name)
> > +  return attr_value
> > +
> > +# Setup attributes common for all compiler-rt projects.
> > +llvm_src_root = get_required_attr(config, 'llvm_src_root')
> > +compiler_rt_lit_unit_cfg = os.path.join(llvm_src_root, "projects",
> > +                                        "compiler-rt", "lib",
> > +                                        "lit.common.unit.cfg")
> > +lit.load_config(config, compiler_rt_lit_unit_cfg)
> > +
> > +# Setup config name.
> > +config.name = 'ThreadSanitizer-Unit'
> > +
> > +# Setup test source and exec root. For unit tests, we define
> > +# it as build directory with TSan unit tests.
> > +llvm_obj_root = get_required_attr(config, "llvm_obj_root")
> > +config.test_exec_root = os.path.join(llvm_obj_root, "projects",
> > +                                     "compiler-rt", "lib",
> > +                                     "tsan", "tests")
> > +config.test_source_root = config.test_exec_root
> >
> > Added: compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.site.cfg.in
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.site.cfg.in?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.site.cfg.in (added)
> > +++ compiler-rt/trunk/lib/tsan/lit_tests/Unit/lit.site.cfg.in Mon Sep
> 17 05:02:17 2012
> > @@ -0,0 +1,9 @@
> > +## Autogenerated by LLVM/Clang configuration.
> > +# Do not edit!
> > +
> > +config.build_type = "@CMAKE_BUILD_TYPE@"
> > +config.llvm_obj_root = "@LLVM_BINARY_DIR@"
> > +config.llvm_src_root = "@LLVM_SOURCE_DIR@"
> > +
> > +# Let the main config do the real work.
> > +lit.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/Unit/lit.cfg")
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/CMakeLists.txt?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/CMakeLists.txt (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/CMakeLists.txt (removed)
> > @@ -1,15 +0,0 @@
> > -set(TSAN_RTL_TESTS
> > -  tsan_bench.cc
> > -  tsan_mop.cc
> > -  tsan_mutex.cc
> > -  tsan_posix.cc
> > -  tsan_string.cc
> > -  tsan_test.cc
> > -  tsan_thread.cc
> > -  )
> > -
> > -if(UNIX AND NOT APPLE)
> > -  list(APPEND TSAN_RTL_TESTS tsan_test_util_linux.cc)
> > -endif()
> > -
> > -add_tsan_unittest(TsanRtlTest ${TSAN_RTL_TESTS})
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_bench.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_bench.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_bench.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_bench.cc (removed)
> > @@ -1,105 +0,0 @@
> > -//===-- tsan_bench.cc
> -----------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_test_util.h"
> > -#include "tsan_interface.h"
> > -#include "tsan_defs.h"
> > -#include "gtest/gtest.h"
> > -#include <stdint.h>
> > -
> > -const int kSize = 128;
> > -const int kRepeat = 2*1024*1024;
> > -
> > -void noinstr(void *p) {}
> > -
> > -template<typename T, void(*__tsan_mop)(void *p)>
> > -static void Benchmark() {
> > -  volatile T data[kSize];
> > -  for (int i = 0; i < kRepeat; i++) {
> > -    for (int j = 0; j < kSize; j++) {
> > -      __tsan_mop((void*)&data[j]);
> > -      data[j]++;
> > -    }
> > -  }
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop1) {
> > -  Benchmark<uint8_t, noinstr>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop1Read) {
> > -  Benchmark<uint8_t, __tsan_read1>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop1Write) {
> > -  Benchmark<uint8_t, __tsan_write1>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop2) {
> > -  Benchmark<uint16_t, noinstr>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop2Read) {
> > -  Benchmark<uint16_t, __tsan_read2>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop2Write) {
> > -  Benchmark<uint16_t, __tsan_write2>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop4) {
> > -  Benchmark<uint32_t, noinstr>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop4Read) {
> > -  Benchmark<uint32_t, __tsan_read4>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop4Write) {
> > -  Benchmark<uint32_t, __tsan_write4>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop8) {
> > -  Benchmark<uint8_t, noinstr>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop8Read) {
> > -  Benchmark<uint64_t, __tsan_read8>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, Mop8Write) {
> > -  Benchmark<uint64_t, __tsan_write8>();
> > -}
> > -
> > -TEST(DISABLED_BENCH, FuncCall) {
> > -  for (int i = 0; i < kRepeat; i++) {
> > -    for (int j = 0; j < kSize; j++)
> > -      __tsan_func_entry((void*)(uintptr_t)j);
> > -    for (int j = 0; j < kSize; j++)
> > -      __tsan_func_exit();
> > -  }
> > -}
> > -
> > -TEST(DISABLED_BENCH, MutexLocal) {
> > -  Mutex m;
> > -  ScopedThread().Create(m);
> > -  for (int i = 0; i < 50; i++) {
> > -    ScopedThread t;
> > -    t.Lock(m);
> > -    t.Unlock(m);
> > -  }
> > -  for (int i = 0; i < 16*1024*1024; i++) {
> > -    m.Lock();
> > -    m.Unlock();
> > -  }
> > -  ScopedThread().Destroy(m);
> > -}
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mop.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mop.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mop.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mop.cc (removed)
> > @@ -1,233 +0,0 @@
> > -//===-- tsan_mop.cc
> -------------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_interface.h"
> > -#include "tsan_test_util.h"
> > -#include "gtest/gtest.h"
> > -#include <stddef.h>
> > -#include <stdint.h>
> > -
> > -TEST(ThreadSanitizer, SimpleWrite) {
> > -  ScopedThread t;
> > -  MemLoc l;
> > -  t.Write1(l);
> > -}
> > -
> > -TEST(ThreadSanitizer, SimpleWriteWrite) {
> > -  ScopedThread t1, t2;
> > -  MemLoc l1, l2;
> > -  t1.Write1(l1);
> > -  t2.Write1(l2);
> > -}
> > -
> > -TEST(ThreadSanitizer, WriteWriteRace) {
> > -  ScopedThread t1, t2;
> > -  MemLoc l;
> > -  t1.Write1(l);
> > -  t2.Write1(l, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, ReadWriteRace) {
> > -  ScopedThread t1, t2;
> > -  MemLoc l;
> > -  t1.Read1(l);
> > -  t2.Write1(l, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, WriteReadRace) {
> > -  ScopedThread t1, t2;
> > -  MemLoc l;
> > -  t1.Write1(l);
> > -  t2.Read1(l, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, ReadReadNoRace) {
> > -  ScopedThread t1, t2;
> > -  MemLoc l;
> > -  t1.Read1(l);
> > -  t2.Read1(l);
> > -}
> > -
> > -TEST(ThreadSanitizer, WriteThenRead) {
> > -  MemLoc l;
> > -  ScopedThread t1, t2;
> > -  t1.Write1(l);
> > -  t1.Read1(l);
> > -  t2.Read1(l, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, WriteThenLockedRead) {
> > -  Mutex m(Mutex::RW);
> > -  MainThread t0;
> > -  t0.Create(m);
> > -  MemLoc l;
> > -  {
> > -    ScopedThread t1, t2;
> > -
> > -    t1.Write8(l);
> > -
> > -    t1.Lock(m);
> > -    t1.Read8(l);
> > -    t1.Unlock(m);
> > -
> > -    t2.Read8(l, true);
> > -  }
> > -  t0.Destroy(m);
> > -}
> > -
> > -TEST(ThreadSanitizer, LockedWriteThenRead) {
> > -  Mutex m(Mutex::RW);
> > -  MainThread t0;
> > -  t0.Create(m);
> > -  MemLoc l;
> > -  {
> > -    ScopedThread t1, t2;
> > -
> > -    t1.Lock(m);
> > -    t1.Write8(l);
> > -    t1.Unlock(m);
> > -
> > -    t1.Read8(l);
> > -
> > -    t2.Read8(l, true);
> > -  }
> > -  t0.Destroy(m);
> > -}
> > -
> > -
> > -TEST(ThreadSanitizer, RaceWithOffset) {
> > -  ScopedThread t1, t2;
> > -  {
> > -    MemLoc l;
> > -    t1.Access(l.loc(), true, 8, false);
> > -    t2.Access((char*)l.loc() + 4, true, 4, true);
> > -  }
> > -  {
> > -    MemLoc l;
> > -    t1.Access(l.loc(), true, 8, false);
> > -    t2.Access((char*)l.loc() + 7, true, 1, true);
> > -  }
> > -  {
> > -    MemLoc l;
> > -    t1.Access((char*)l.loc() + 4, true, 4, false);
> > -    t2.Access((char*)l.loc() + 4, true, 2, true);
> > -  }
> > -  {
> > -    MemLoc l;
> > -    t1.Access((char*)l.loc() + 4, true, 4, false);
> > -    t2.Access((char*)l.loc() + 6, true, 2, true);
> > -  }
> > -  {
> > -    MemLoc l;
> > -    t1.Access((char*)l.loc() + 3, true, 2, false);
> > -    t2.Access((char*)l.loc() + 4, true, 1, true);
> > -  }
> > -  {
> > -    MemLoc l;
> > -    t1.Access((char*)l.loc() + 1, true, 8, false);
> > -    t2.Access((char*)l.loc() + 3, true, 1, true);
> > -  }
> > -}
> > -
> > -TEST(ThreadSanitizer, RaceWithOffset2) {
> > -  ScopedThread t1, t2;
> > -  {
> > -    MemLoc l;
> > -    t1.Access((char*)l.loc(), true, 4, false);
> > -    t2.Access((char*)l.loc() + 2, true, 1, true);
> > -  }
> > -  {
> > -    MemLoc l;
> > -    t1.Access((char*)l.loc() + 2, true, 1, false);
> > -    t2.Access((char*)l.loc(), true, 4, true);
> > -  }
> > -}
> > -
> > -TEST(ThreadSanitizer, NoRaceWithOffset) {
> > -  ScopedThread t1, t2;
> > -  {
> > -    MemLoc l;
> > -    t1.Access(l.loc(), true, 4, false);
> > -    t2.Access((char*)l.loc() + 4, true, 4, false);
> > -  }
> > -  {
> > -    MemLoc l;
> > -    t1.Access((char*)l.loc() + 3, true, 2, false);
> > -    t2.Access((char*)l.loc() + 1, true, 2, false);
> > -    t2.Access((char*)l.loc() + 5, true, 2, false);
> > -  }
> > -}
> > -
> > -TEST(ThreadSanitizer, RaceWithDeadThread) {
> > -  MemLoc l;
> > -  ScopedThread t;
> > -  ScopedThread().Write1(l);
> > -  t.Write1(l, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, BenignRaceOnVptr) {
> > -  void *vptr_storage;
> > -  MemLoc vptr(&vptr_storage), val;
> > -  vptr_storage = val.loc();
> > -  ScopedThread t1, t2;
> > -  t1.VptrUpdate(vptr, val);
> > -  t2.Read8(vptr);
> > -}
> > -
> > -TEST(ThreadSanitizer, HarmfulRaceOnVptr) {
> > -  void *vptr_storage;
> > -  MemLoc vptr(&vptr_storage), val1, val2;
> > -  vptr_storage = val1.loc();
> > -  ScopedThread t1, t2;
> > -  t1.VptrUpdate(vptr, val2);
> > -  t2.Read8(vptr, true);
> > -}
> > -
> > -static void foo() {
> > -  volatile int x = 42;
> > -  int x2 = x;
> > -  (void)x2;
> > -}
> > -
> > -static void bar() {
> > -  volatile int x = 43;
> > -  int x2 = x;
> > -  (void)x2;
> > -}
> > -
> > -TEST(ThreadSanitizer, ReportDeadThread) {
> > -  MemLoc l;
> > -  ScopedThread t1;
> > -  {
> > -    ScopedThread t2;
> > -    t2.Call(&foo);
> > -    t2.Call(&bar);
> > -    t2.Write1(l);
> > -  }
> > -  t1.Write1(l, true);
> > -}
> > -
> > -struct ClassWithStatic {
> > -  static int Data[4];
> > -};
> > -
> > -int ClassWithStatic::Data[4];
> > -
> > -static void foobarbaz() {}
> > -
> > -TEST(ThreadSanitizer, ReportRace) {
> > -  ScopedThread t1;
> > -  MainThread().Access(&ClassWithStatic::Data, true, 4, false);
> > -  t1.Call(&foobarbaz);
> > -  t1.Access(&ClassWithStatic::Data, true, 2, true);
> > -  t1.Return();
> > -}
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mutex.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mutex.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mutex.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_mutex.cc (removed)
> > @@ -1,221 +0,0 @@
> > -//===-- tsan_mutex.cc
> -----------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "sanitizer_common/sanitizer_atomic.h"
> > -#include "tsan_interface.h"
> > -#include "tsan_interface_ann.h"
> > -#include "tsan_test_util.h"
> > -#include "gtest/gtest.h"
> > -#include <stdint.h>
> > -
> > -namespace __tsan {
> > -
> > -TEST(ThreadSanitizer, BasicMutex) {
> > -  ScopedThread t;
> > -  Mutex m;
> > -  t.Create(m);
> > -
> > -  t.Lock(m);
> > -  t.Unlock(m);
> > -
> > -  CHECK(t.TryLock(m));
> > -  t.Unlock(m);
> > -
> > -  t.Lock(m);
> > -  CHECK(!t.TryLock(m));
> > -  t.Unlock(m);
> > -
> > -  t.Destroy(m);
> > -}
> > -
> > -TEST(ThreadSanitizer, BasicSpinMutex) {
> > -  ScopedThread t;
> > -  Mutex m(Mutex::Spin);
> > -  t.Create(m);
> > -
> > -  t.Lock(m);
> > -  t.Unlock(m);
> > -
> > -  CHECK(t.TryLock(m));
> > -  t.Unlock(m);
> > -
> > -  t.Lock(m);
> > -  CHECK(!t.TryLock(m));
> > -  t.Unlock(m);
> > -
> > -  t.Destroy(m);
> > -}
> > -
> > -TEST(ThreadSanitizer, BasicRwMutex) {
> > -  ScopedThread t;
> > -  Mutex m(Mutex::RW);
> > -  t.Create(m);
> > -
> > -  t.Lock(m);
> > -  t.Unlock(m);
> > -
> > -  CHECK(t.TryLock(m));
> > -  t.Unlock(m);
> > -
> > -  t.Lock(m);
> > -  CHECK(!t.TryLock(m));
> > -  t.Unlock(m);
> > -
> > -  t.ReadLock(m);
> > -  t.ReadUnlock(m);
> > -
> > -  CHECK(t.TryReadLock(m));
> > -  t.ReadUnlock(m);
> > -
> > -  t.Lock(m);
> > -  CHECK(!t.TryReadLock(m));
> > -  t.Unlock(m);
> > -
> > -  t.ReadLock(m);
> > -  CHECK(!t.TryLock(m));
> > -  t.ReadUnlock(m);
> > -
> > -  t.ReadLock(m);
> > -  CHECK(t.TryReadLock(m));
> > -  t.ReadUnlock(m);
> > -  t.ReadUnlock(m);
> > -
> > -  t.Destroy(m);
> > -}
> > -
> > -TEST(ThreadSanitizer, Mutex) {
> > -  Mutex m;
> > -  MainThread t0;
> > -  t0.Create(m);
> > -
> > -  ScopedThread t1, t2;
> > -  MemLoc l;
> > -  t1.Lock(m);
> > -  t1.Write1(l);
> > -  t1.Unlock(m);
> > -  t2.Lock(m);
> > -  t2.Write1(l);
> > -  t2.Unlock(m);
> > -  t2.Destroy(m);
> > -}
> > -
> > -TEST(ThreadSanitizer, SpinMutex) {
> > -  Mutex m(Mutex::Spin);
> > -  MainThread t0;
> > -  t0.Create(m);
> > -
> > -  ScopedThread t1, t2;
> > -  MemLoc l;
> > -  t1.Lock(m);
> > -  t1.Write1(l);
> > -  t1.Unlock(m);
> > -  t2.Lock(m);
> > -  t2.Write1(l);
> > -  t2.Unlock(m);
> > -  t2.Destroy(m);
> > -}
> > -
> > -TEST(ThreadSanitizer, RwMutex) {
> > -  Mutex m(Mutex::RW);
> > -  MainThread t0;
> > -  t0.Create(m);
> > -
> > -  ScopedThread t1, t2, t3;
> > -  MemLoc l;
> > -  t1.Lock(m);
> > -  t1.Write1(l);
> > -  t1.Unlock(m);
> > -  t2.Lock(m);
> > -  t2.Write1(l);
> > -  t2.Unlock(m);
> > -  t1.ReadLock(m);
> > -  t3.ReadLock(m);
> > -  t1.Read1(l);
> > -  t3.Read1(l);
> > -  t1.ReadUnlock(m);
> > -  t3.ReadUnlock(m);
> > -  t2.Lock(m);
> > -  t2.Write1(l);
> > -  t2.Unlock(m);
> > -  t2.Destroy(m);
> > -}
> > -
> > -TEST(ThreadSanitizer, StaticMutex) {
> > -  // Emulates statically initialized mutex.
> > -  Mutex m;
> > -  m.StaticInit();
> > -  {
> > -    ScopedThread t1, t2;
> > -    t1.Lock(m);
> > -    t1.Unlock(m);
> > -    t2.Lock(m);
> > -    t2.Unlock(m);
> > -  }
> > -  MainThread().Destroy(m);
> > -}
> > -
> > -static void *singleton_thread(void *param) {
> > -  atomic_uintptr_t *singleton = (atomic_uintptr_t *)param;
> > -  for (int i = 0; i < 4*1024*1024; i++) {
> > -    int *val = (int *)atomic_load(singleton, memory_order_acquire);
> > -    __tsan_acquire(singleton);
> > -    __tsan_read4(val);
> > -    CHECK_EQ(*val, 42);
> > -  }
> > -  return 0;
> > -}
> > -
> > -TEST(DISABLED_BENCH_ThreadSanitizer, Singleton) {
> > -  const int kClockSize = 100;
> > -  const int kThreadCount = 8;
> > -
> > -  // Puff off thread's clock.
> > -  for (int i = 0; i < kClockSize; i++) {
> > -    ScopedThread t1;
> > -    (void)t1;
> > -  }
> > -  // Create the singleton.
> > -  int val = 42;
> > -  __tsan_write4(&val);
> > -  atomic_uintptr_t singleton;
> > -  __tsan_release(&singleton);
> > -  atomic_store(&singleton, (uintptr_t)&val, memory_order_release);
> > -  // Create reader threads.
> > -  pthread_t threads[kThreadCount];
> > -  for (int t = 0; t < kThreadCount; t++)
> > -    pthread_create(&threads[t], 0, singleton_thread, &singleton);
> > -  for (int t = 0; t < kThreadCount; t++)
> > -    pthread_join(threads[t], 0);
> > -}
> > -
> > -TEST(DISABLED_BENCH_ThreadSanitizer, StopFlag) {
> > -  const int kClockSize = 100;
> > -  const int kIters = 16*1024*1024;
> > -
> > -  // Puff off thread's clock.
> > -  for (int i = 0; i < kClockSize; i++) {
> > -    ScopedThread t1;
> > -    (void)t1;
> > -  }
> > -  // Create the stop flag.
> > -  atomic_uintptr_t flag;
> > -  __tsan_release(&flag);
> > -  atomic_store(&flag, 0, memory_order_release);
> > -  // Read it a lot.
> > -  for (int i = 0; i < kIters; i++) {
> > -    uptr v = atomic_load(&flag, memory_order_acquire);
> > -    __tsan_acquire(&flag);
> > -    CHECK_EQ(v, 0);
> > -  }
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_posix.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_posix.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_posix.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_posix.cc (removed)
> > @@ -1,146 +0,0 @@
> > -//===-- tsan_posix.cc
> -----------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_interface.h"
> > -#include "tsan_test_util.h"
> > -#include "gtest/gtest.h"
> > -#include <pthread.h>
> > -
> > -struct thread_key {
> > -  pthread_key_t key;
> > -  pthread_mutex_t *mtx;
> > -  int val;
> > -  int *cnt;
> > -  thread_key(pthread_key_t key, pthread_mutex_t *mtx, int val, int *cnt)
> > -    : key(key)
> > -    , mtx(mtx)
> > -    , val(val)
> > -    , cnt(cnt) {
> > -  }
> > -};
> > -
> > -static void thread_secific_dtor(void *v) {
> > -  thread_key *k = (thread_key *)v;
> > -  EXPECT_EQ(pthread_mutex_lock(k->mtx), 0);
> > -  (*k->cnt)++;
> > -  __tsan_write4(&k->cnt);
> > -  EXPECT_EQ(pthread_mutex_unlock(k->mtx), 0);
> > -  if (k->val == 42) {
> > -    delete k;
> > -  } else if (k->val == 43 || k->val == 44) {
> > -    k->val--;
> > -    EXPECT_EQ(pthread_setspecific(k->key, k), 0);
> > -  } else {
> > -    ASSERT_TRUE(false);
> > -  }
> > -}
> > -
> > -static void *dtors_thread(void *p) {
> > -  thread_key *k = (thread_key *)p;
> > -  EXPECT_EQ(pthread_setspecific(k->key, k), 0);
> > -  return 0;
> > -}
> > -
> > -TEST(Posix, ThreadSpecificDtors) {
> > -  int cnt = 0;
> > -  pthread_key_t key;
> > -  EXPECT_EQ(pthread_key_create(&key, thread_secific_dtor), 0);
> > -  pthread_mutex_t mtx;
> > -  EXPECT_EQ(pthread_mutex_init(&mtx, 0), 0);
> > -  pthread_t th[3];
> > -  thread_key *k[3];
> > -  k[0] = new thread_key(key, &mtx, 42, &cnt);
> > -  k[1] = new thread_key(key, &mtx, 43, &cnt);
> > -  k[2] = new thread_key(key, &mtx, 44, &cnt);
> > -  EXPECT_EQ(pthread_create(&th[0], 0, dtors_thread, k[0]), 0);
> > -  EXPECT_EQ(pthread_create(&th[1], 0, dtors_thread, k[1]), 0);
> > -  EXPECT_EQ(pthread_join(th[0], 0), 0);
> > -  EXPECT_EQ(pthread_create(&th[2], 0, dtors_thread, k[2]), 0);
> > -  EXPECT_EQ(pthread_join(th[1], 0), 0);
> > -  EXPECT_EQ(pthread_join(th[2], 0), 0);
> > -  EXPECT_EQ(pthread_key_delete(key), 0);
> > -  EXPECT_EQ(6, cnt);
> > -}
> > -
> > -static __thread int local_var;
> > -
> > -static void *local_thread(void *p) {
> > -  __tsan_write1(&local_var);
> > -  __tsan_write1(&p);
> > -  if (p == 0)
> > -    return 0;
> > -  const int kThreads = 4;
> > -  pthread_t th[kThreads];
> > -  for (int i = 0; i < kThreads; i++)
> > -    EXPECT_EQ(pthread_create(&th[i], 0, local_thread,
> > -              (void*)((long)p - 1)), 0);  // NOLINT
> > -  for (int i = 0; i < kThreads; i++)
> > -    EXPECT_EQ(pthread_join(th[i], 0), 0);
> > -  return 0;
> > -}
> > -
> > -TEST(Posix, ThreadLocalAccesses) {
> > -  local_thread((void*)2);
> > -}
> > -
> > -struct CondContext {
> > -  pthread_mutex_t m;
> > -  pthread_cond_t c;
> > -  int data;
> > -};
> > -
> > -static void *cond_thread(void *p) {
> > -  CondContext &ctx = *static_cast<CondContext*>(p);
> > -
> > -  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > -  EXPECT_EQ(ctx.data, 0);
> > -  ctx.data = 1;
> > -  EXPECT_EQ(pthread_cond_signal(&ctx.c), 0);
> > -  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > -
> > -  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > -  while (ctx.data != 2)
> > -    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
> > -  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > -
> > -  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > -  ctx.data = 3;
> > -  EXPECT_EQ(pthread_cond_broadcast(&ctx.c), 0);
> > -  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > -
> > -  return 0;
> > -}
> > -
> > -TEST(Posix, CondBasic) {
> > -  CondContext ctx;
> > -  EXPECT_EQ(pthread_mutex_init(&ctx.m, 0), 0);
> > -  EXPECT_EQ(pthread_cond_init(&ctx.c, 0), 0);
> > -  ctx.data = 0;
> > -  pthread_t th;
> > -  EXPECT_EQ(pthread_create(&th, 0, cond_thread, &ctx), 0);
> > -
> > -  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > -  while (ctx.data != 1)
> > -    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
> > -  ctx.data = 2;
> > -  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > -  EXPECT_EQ(pthread_cond_broadcast(&ctx.c), 0);
> > -
> > -  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > -  while (ctx.data != 3)
> > -    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
> > -  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > -
> > -  EXPECT_EQ(pthread_join(th, 0), 0);
> > -  EXPECT_EQ(pthread_cond_destroy(&ctx.c), 0);
> > -  EXPECT_EQ(pthread_mutex_destroy(&ctx.m), 0);
> > -}
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_string.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_string.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_string.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_string.cc (removed)
> > @@ -1,82 +0,0 @@
> > -//===-- tsan_string.cc
> ----------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_test_util.h"
> > -#include "gtest/gtest.h"
> > -#include <string.h>
> > -
> > -namespace __tsan {
> > -
> > -TEST(ThreadSanitizer, Memcpy) {
> > -  char data0[7] = {1, 2, 3, 4, 5, 6, 7};
> > -  char data[7] = {42, 42, 42, 42, 42, 42, 42};
> > -  MainThread().Memcpy(data+1, data0+1, 5);
> > -  EXPECT_EQ(data[0], 42);
> > -  EXPECT_EQ(data[1], 2);
> > -  EXPECT_EQ(data[2], 3);
> > -  EXPECT_EQ(data[3], 4);
> > -  EXPECT_EQ(data[4], 5);
> > -  EXPECT_EQ(data[5], 6);
> > -  EXPECT_EQ(data[6], 42);
> > -  MainThread().Memset(data+1, 13, 5);
> > -  EXPECT_EQ(data[0], 42);
> > -  EXPECT_EQ(data[1], 13);
> > -  EXPECT_EQ(data[2], 13);
> > -  EXPECT_EQ(data[3], 13);
> > -  EXPECT_EQ(data[4], 13);
> > -  EXPECT_EQ(data[5], 13);
> > -  EXPECT_EQ(data[6], 42);
> > -}
> > -
> > -TEST(ThreadSanitizer, MemcpyRace1) {
> > -  char *data = new char[10];
> > -  char *data1 = new char[10];
> > -  char *data2 = new char[10];
> > -  ScopedThread t1, t2;
> > -  t1.Memcpy(data, data1, 10);
> > -  t2.Memcpy(data, data2, 10, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, MemcpyRace2) {
> > -  char *data = new char[10];
> > -  char *data1 = new char[10];
> > -  char *data2 = new char[10];
> > -  ScopedThread t1, t2;
> > -  t1.Memcpy(data+5, data1, 1);
> > -  t2.Memcpy(data+3, data2, 4, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, MemcpyRace3) {
> > -  char *data = new char[10];
> > -  char *data1 = new char[10];
> > -  char *data2 = new char[10];
> > -  ScopedThread t1, t2;
> > -  t1.Memcpy(data, data1, 10);
> > -  t2.Memcpy(data1, data2, 10, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, MemcpyStack) {
> > -  char *data = new char[10];
> > -  char *data1 = new char[10];
> > -  ScopedThread t1, t2;
> > -  t1.Memcpy(data, data1, 10);
> > -  t2.Memcpy(data, data1, 10, true);
> > -}
> > -
> > -TEST(ThreadSanitizer, MemsetRace1) {
> > -  char *data = new char[10];
> > -  ScopedThread t1, t2;
> > -  t1.Memset(data, 1, 10);
> > -  t2.Memset(data, 2, 10, true);
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test.cc (removed)
> > @@ -1,44 +0,0 @@
> > -//===-- tsan_test.cc
> ------------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_interface.h"
> > -#include "tsan_test_util.h"
> > -#include "gtest/gtest.h"
> > -
> > -static void foo() {}
> > -static void bar() {}
> > -
> > -TEST(ThreadSanitizer, FuncCall) {
> > -  ScopedThread t1, t2;
> > -  MemLoc l;
> > -  t1.Write1(l);
> > -  t2.Call(foo);
> > -  t2.Call(bar);
> > -  t2.Write1(l, true);
> > -  t2.Return();
> > -  t2.Return();
> > -}
> > -
> > -int main(int argc, char **argv) {
> > -  TestMutexBeforeInit();  // Mutexes must be usable before
> __tsan_init();
> > -  __tsan_init();
> > -  __tsan_func_entry(__builtin_return_address(0));
> > -  __tsan_func_entry((char*)&main + 1);
> > -
> > -  testing::GTEST_FLAG(death_test_style) = "threadsafe";
> > -  testing::InitGoogleTest(&argc, argv);
> > -  int res = RUN_ALL_TESTS();
> > -
> > -  __tsan_func_exit();
> > -  __tsan_func_exit();
> > -  return res;
> > -}
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util.h
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util.h?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util.h (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util.h (removed)
> > @@ -1,122 +0,0 @@
> > -//===-- tsan_test_util.h ----------------------------------------*- C++
> -*-===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> > -// Test utils.
> >
> -//===----------------------------------------------------------------------===//
> > -#ifndef TSAN_TEST_UTIL_H
> > -#define TSAN_TEST_UTIL_H
> > -
> > -void TestMutexBeforeInit();
> > -
> > -// A location of memory on which a race may be detected.
> > -class MemLoc {
> > - public:
> > -  explicit MemLoc(int offset_from_aligned = 0);
> > -  explicit MemLoc(void *const real_addr) : loc_(real_addr) { }
> > -  ~MemLoc();
> > -  void *loc() const { return loc_; }
> > - private:
> > -  void *const loc_;
> > -  MemLoc(const MemLoc&);
> > -  void operator = (const MemLoc&);
> > -};
> > -
> > -class Mutex {
> > - public:
> > -  enum Type { Normal, Spin, RW };
> > -
> > -  explicit Mutex(Type type = Normal);
> > -  ~Mutex();
> > -
> > -  void Init();
> > -  void StaticInit();  // Emulates static initalization (tsan invisible).
> > -  void Destroy();
> > -  void Lock();
> > -  bool TryLock();
> > -  void Unlock();
> > -  void ReadLock();
> > -  bool TryReadLock();
> > -  void ReadUnlock();
> > -
> > - private:
> > -  // Placeholder for pthread_mutex_t, CRITICAL_SECTION or whatever.
> > -  void *mtx_[128];
> > -  bool alive_;
> > -  const Type type_;
> > -
> > -  Mutex(const Mutex&);
> > -  void operator = (const Mutex&);
> > -};
> > -
> > -// A thread is started in CTOR and joined in DTOR.
> > -class ScopedThread {
> > - public:
> > -  explicit ScopedThread(bool detached = false, bool main = false);
> > -  ~ScopedThread();
> > -  void Detach();
> > -
> > -  void Access(void *addr, bool is_write, int size, bool expect_race);
> > -  void Read(const MemLoc &ml, int size, bool expect_race = false) {
> > -    Access(ml.loc(), false, size, expect_race);
> > -  }
> > -  void Write(const MemLoc &ml, int size, bool expect_race = false) {
> > -    Access(ml.loc(), true, size, expect_race);
> > -  }
> > -  void Read1(const MemLoc &ml, bool expect_race = false) {
> > -    Read(ml, 1, expect_race); }
> > -  void Read2(const MemLoc &ml, bool expect_race = false) {
> > -    Read(ml, 2, expect_race); }
> > -  void Read4(const MemLoc &ml, bool expect_race = false) {
> > -    Read(ml, 4, expect_race); }
> > -  void Read8(const MemLoc &ml, bool expect_race = false) {
> > -    Read(ml, 8, expect_race); }
> > -  void Write1(const MemLoc &ml, bool expect_race = false) {
> > -    Write(ml, 1, expect_race); }
> > -  void Write2(const MemLoc &ml, bool expect_race = false) {
> > -    Write(ml, 2, expect_race); }
> > -  void Write4(const MemLoc &ml, bool expect_race = false) {
> > -    Write(ml, 4, expect_race); }
> > -  void Write8(const MemLoc &ml, bool expect_race = false) {
> > -    Write(ml, 8, expect_race); }
> > -
> > -  void VptrUpdate(const MemLoc &vptr, const MemLoc &new_val,
> > -                  bool expect_race = false);
> > -
> > -  void Call(void(*pc)());
> > -  void Return();
> > -
> > -  void Create(const Mutex &m);
> > -  void Destroy(const Mutex &m);
> > -  void Lock(const Mutex &m);
> > -  bool TryLock(const Mutex &m);
> > -  void Unlock(const Mutex &m);
> > -  void ReadLock(const Mutex &m);
> > -  bool TryReadLock(const Mutex &m);
> > -  void ReadUnlock(const Mutex &m);
> > -
> > -  void Memcpy(void *dst, const void *src, int size, bool expect_race =
> false);
> > -  void Memset(void *dst, int val, int size, bool expect_race = false);
> > -
> > - private:
> > -  struct Impl;
> > -  Impl *impl_;
> > -  ScopedThread(const ScopedThread&);  // Not implemented.
> > -  void operator = (const ScopedThread&);  // Not implemented.
> > -};
> > -
> > -class MainThread : public ScopedThread {
> > - public:
> > -  MainThread()
> > -    : ScopedThread(false, true) {
> > -  }
> > -};
> > -
> > -#endif  // #ifndef TSAN_TEST_UTIL_H
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util_linux.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util_linux.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util_linux.cc
> (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_test_util_linux.cc
> (removed)
> > @@ -1,465 +0,0 @@
> > -
> > -//===-- tsan_test_util_linux.cc
> -------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> > -// Test utils, linux implementation.
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#include "sanitizer_common/sanitizer_atomic.h"
> > -#include "tsan_interface.h"
> > -#include "tsan_test_util.h"
> > -#include "tsan_report.h"
> > -
> > -#include "gtest/gtest.h"
> > -
> > -#include <assert.h>
> > -#include <pthread.h>
> > -#include <stdio.h>
> > -#include <stdint.h>
> > -#include <string.h>
> > -#include <unistd.h>
> > -#include <errno.h>
> > -
> > -using namespace __tsan;  // NOLINT
> > -
> > -static __thread bool expect_report;
> > -static __thread bool expect_report_reported;
> > -static __thread ReportType expect_report_type;
> > -
> > -extern "C" void *__interceptor_memcpy(void*, const void*, uptr);
> > -extern "C" void *__interceptor_memset(void*, int, uptr);
> > -
> > -static void *BeforeInitThread(void *param) {
> > -  (void)param;
> > -  return 0;
> > -}
> > -
> > -static void AtExit() {
> > -}
> > -
> > -void TestMutexBeforeInit() {
> > -  // Mutexes must be usable before __tsan_init();
> > -  pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
> > -  pthread_mutex_lock(&mtx);
> > -  pthread_mutex_unlock(&mtx);
> > -  pthread_mutex_destroy(&mtx);
> > -  pthread_t thr;
> > -  pthread_create(&thr, 0, BeforeInitThread, 0);
> > -  pthread_join(thr, 0);
> > -  atexit(AtExit);
> > -}
> > -
> > -namespace __tsan {
> > -bool OnReport(const ReportDesc *rep, bool suppressed) {
> > -  if (expect_report) {
> > -    if (rep->typ != expect_report_type) {
> > -      printf("Expected report of type %d, got type %d\n",
> > -             (int)expect_report_type, (int)rep->typ);
> > -      EXPECT_FALSE("Wrong report type");
> > -      return false;
> > -    }
> > -  } else {
> > -    EXPECT_FALSE("Unexpected report");
> > -    return false;
> > -  }
> > -  expect_report_reported = true;
> > -  return true;
> > -}
> > -}
> > -
> > -static void* allocate_addr(int size, int offset_from_aligned = 0) {
> > -  static uintptr_t foo;
> > -  static atomic_uintptr_t uniq = {(uintptr_t)&foo};  // Some real
> address.
> > -  const int kAlign = 16;
> > -  CHECK(offset_from_aligned < kAlign);
> > -  size = (size + 2 * kAlign) & ~(kAlign - 1);
> > -  uintptr_t addr = atomic_fetch_add(&uniq, size, memory_order_relaxed);
> > -  return (void*)(addr + offset_from_aligned);
> > -}
> > -
> > -MemLoc::MemLoc(int offset_from_aligned)
> > -  : loc_(allocate_addr(16, offset_from_aligned)) {
> > -}
> > -
> > -MemLoc::~MemLoc() {
> > -}
> > -
> > -Mutex::Mutex(Type type)
> > -  : alive_()
> > -  , type_(type) {
> > -}
> > -
> > -Mutex::~Mutex() {
> > -  CHECK(!alive_);
> > -}
> > -
> > -void Mutex::Init() {
> > -  CHECK(!alive_);
> > -  alive_ = true;
> > -  if (type_ == Normal)
> > -    CHECK_EQ(pthread_mutex_init((pthread_mutex_t*)mtx_, 0), 0);
> > -  else if (type_ == Spin)
> > -    CHECK_EQ(pthread_spin_init((pthread_spinlock_t*)mtx_, 0), 0);
> > -  else if (type_ == RW)
> > -    CHECK_EQ(pthread_rwlock_init((pthread_rwlock_t*)mtx_, 0), 0);
> > -  else
> > -    CHECK(0);
> > -}
> > -
> > -void Mutex::StaticInit() {
> > -  CHECK(!alive_);
> > -  CHECK(type_ == Normal);
> > -  alive_ = true;
> > -  pthread_mutex_t tmp = PTHREAD_MUTEX_INITIALIZER;
> > -  memcpy(mtx_, &tmp, sizeof(tmp));
> > -}
> > -
> > -void Mutex::Destroy() {
> > -  CHECK(alive_);
> > -  alive_ = false;
> > -  if (type_ == Normal)
> > -    CHECK_EQ(pthread_mutex_destroy((pthread_mutex_t*)mtx_), 0);
> > -  else if (type_ == Spin)
> > -    CHECK_EQ(pthread_spin_destroy((pthread_spinlock_t*)mtx_), 0);
> > -  else if (type_ == RW)
> > -    CHECK_EQ(pthread_rwlock_destroy((pthread_rwlock_t*)mtx_), 0);
> > -}
> > -
> > -void Mutex::Lock() {
> > -  CHECK(alive_);
> > -  if (type_ == Normal)
> > -    CHECK_EQ(pthread_mutex_lock((pthread_mutex_t*)mtx_), 0);
> > -  else if (type_ == Spin)
> > -    CHECK_EQ(pthread_spin_lock((pthread_spinlock_t*)mtx_), 0);
> > -  else if (type_ == RW)
> > -    CHECK_EQ(pthread_rwlock_wrlock((pthread_rwlock_t*)mtx_), 0);
> > -}
> > -
> > -bool Mutex::TryLock() {
> > -  CHECK(alive_);
> > -  if (type_ == Normal)
> > -    return pthread_mutex_trylock((pthread_mutex_t*)mtx_) == 0;
> > -  else if (type_ == Spin)
> > -    return pthread_spin_trylock((pthread_spinlock_t*)mtx_) == 0;
> > -  else if (type_ == RW)
> > -    return pthread_rwlock_trywrlock((pthread_rwlock_t*)mtx_) == 0;
> > -  return false;
> > -}
> > -
> > -void Mutex::Unlock() {
> > -  CHECK(alive_);
> > -  if (type_ == Normal)
> > -    CHECK_EQ(pthread_mutex_unlock((pthread_mutex_t*)mtx_), 0);
> > -  else if (type_ == Spin)
> > -    CHECK_EQ(pthread_spin_unlock((pthread_spinlock_t*)mtx_), 0);
> > -  else if (type_ == RW)
> > -    CHECK_EQ(pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
> > -}
> > -
> > -void Mutex::ReadLock() {
> > -  CHECK(alive_);
> > -  CHECK(type_ == RW);
> > -  CHECK_EQ(pthread_rwlock_rdlock((pthread_rwlock_t*)mtx_), 0);
> > -}
> > -
> > -bool Mutex::TryReadLock() {
> > -  CHECK(alive_);
> > -  CHECK(type_ == RW);
> > -  return pthread_rwlock_tryrdlock((pthread_rwlock_t*)mtx_) ==  0;
> > -}
> > -
> > -void Mutex::ReadUnlock() {
> > -  CHECK(alive_);
> > -  CHECK(type_ == RW);
> > -  CHECK_EQ(pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
> > -}
> > -
> > -struct Event {
> > -  enum Type {
> > -    SHUTDOWN,
> > -    READ,
> > -    WRITE,
> > -    VPTR_UPDATE,
> > -    CALL,
> > -    RETURN,
> > -    MUTEX_CREATE,
> > -    MUTEX_DESTROY,
> > -    MUTEX_LOCK,
> > -    MUTEX_TRYLOCK,
> > -    MUTEX_UNLOCK,
> > -    MUTEX_READLOCK,
> > -    MUTEX_TRYREADLOCK,
> > -    MUTEX_READUNLOCK,
> > -    MEMCPY,
> > -    MEMSET
> > -  };
> > -  Type type;
> > -  void *ptr;
> > -  uptr arg;
> > -  uptr arg2;
> > -  bool res;
> > -  bool expect_report;
> > -  ReportType report_type;
> > -
> > -  Event(Type type, const void *ptr = 0, uptr arg = 0, uptr arg2 = 0)
> > -    : type(type)
> > -    , ptr(const_cast<void*>(ptr))
> > -    , arg(arg)
> > -    , arg2(arg2)
> > -    , res()
> > -    , expect_report()
> > -    , report_type() {
> > -  }
> > -
> > -  void ExpectReport(ReportType type) {
> > -    expect_report = true;
> > -    report_type = type;
> > -  }
> > -};
> > -
> > -struct ScopedThread::Impl {
> > -  pthread_t thread;
> > -  bool main;
> > -  bool detached;
> > -  atomic_uintptr_t event;  // Event*
> > -
> > -  static void *ScopedThreadCallback(void *arg);
> > -  void send(Event *ev);
> > -  void HandleEvent(Event *ev);
> > -};
> > -
> > -void ScopedThread::Impl::HandleEvent(Event *ev) {
> > -  CHECK_EQ(expect_report, false);
> > -  expect_report = ev->expect_report;
> > -  expect_report_reported = false;
> > -  expect_report_type = ev->report_type;
> > -  switch (ev->type) {
> > -  case Event::READ:
> > -  case Event::WRITE: {
> > -    void (*tsan_mop)(void *addr) = 0;
> > -    if (ev->type == Event::READ) {
> > -      switch (ev->arg /*size*/) {
> > -        case 1: tsan_mop = __tsan_read1; break;
> > -        case 2: tsan_mop = __tsan_read2; break;
> > -        case 4: tsan_mop = __tsan_read4; break;
> > -        case 8: tsan_mop = __tsan_read8; break;
> > -        case 16: tsan_mop = __tsan_read16; break;
> > -      }
> > -    } else {
> > -      switch (ev->arg /*size*/) {
> > -        case 1: tsan_mop = __tsan_write1; break;
> > -        case 2: tsan_mop = __tsan_write2; break;
> > -        case 4: tsan_mop = __tsan_write4; break;
> > -        case 8: tsan_mop = __tsan_write8; break;
> > -        case 16: tsan_mop = __tsan_write16; break;
> > -      }
> > -    }
> > -    CHECK_NE(tsan_mop, 0);
> > -    errno = ECHRNG;
> > -    tsan_mop(ev->ptr);
> > -    CHECK_EQ(errno, ECHRNG);  // In no case must errno be changed.
> > -    break;
> > -  }
> > -  case Event::VPTR_UPDATE:
> > -    __tsan_vptr_update((void**)ev->ptr, (void*)ev->arg);
> > -    break;
> > -  case Event::CALL:
> > -    __tsan_func_entry((void*)((uptr)ev->ptr));
> > -    break;
> > -  case Event::RETURN:
> > -    __tsan_func_exit();
> > -    break;
> > -  case Event::MUTEX_CREATE:
> > -    static_cast<Mutex*>(ev->ptr)->Init();
> > -    break;
> > -  case Event::MUTEX_DESTROY:
> > -    static_cast<Mutex*>(ev->ptr)->Destroy();
> > -    break;
> > -  case Event::MUTEX_LOCK:
> > -    static_cast<Mutex*>(ev->ptr)->Lock();
> > -    break;
> > -  case Event::MUTEX_TRYLOCK:
> > -    ev->res = static_cast<Mutex*>(ev->ptr)->TryLock();
> > -    break;
> > -  case Event::MUTEX_UNLOCK:
> > -    static_cast<Mutex*>(ev->ptr)->Unlock();
> > -    break;
> > -  case Event::MUTEX_READLOCK:
> > -    static_cast<Mutex*>(ev->ptr)->ReadLock();
> > -    break;
> > -  case Event::MUTEX_TRYREADLOCK:
> > -    ev->res = static_cast<Mutex*>(ev->ptr)->TryReadLock();
> > -    break;
> > -  case Event::MUTEX_READUNLOCK:
> > -    static_cast<Mutex*>(ev->ptr)->ReadUnlock();
> > -    break;
> > -  case Event::MEMCPY:
> > -    __interceptor_memcpy(ev->ptr, (void*)ev->arg, ev->arg2);
> > -    break;
> > -  case Event::MEMSET:
> > -    __interceptor_memset(ev->ptr, ev->arg, ev->arg2);
> > -    break;
> > -  default: CHECK(0);
> > -  }
> > -  if (expect_report && !expect_report_reported) {
> > -    printf("Missed expected report of type %d\n", (int)ev->report_type);
> > -    EXPECT_FALSE("Missed expected race");
> > -  }
> > -  expect_report = false;
> > -}
> > -
> > -void *ScopedThread::Impl::ScopedThreadCallback(void *arg) {
> > -  __tsan_func_entry(__builtin_return_address(0));
> > -  Impl *impl = (Impl*)arg;
> > -  for (;;) {
> > -    Event* ev = (Event*)atomic_load(&impl->event, memory_order_acquire);
> > -    if (ev == 0) {
> > -      pthread_yield();
> > -      continue;
> > -    }
> > -    if (ev->type == Event::SHUTDOWN) {
> > -      atomic_store(&impl->event, 0, memory_order_release);
> > -      break;
> > -    }
> > -    impl->HandleEvent(ev);
> > -    atomic_store(&impl->event, 0, memory_order_release);
> > -  }
> > -  __tsan_func_exit();
> > -  return 0;
> > -}
> > -
> > -void ScopedThread::Impl::send(Event *e) {
> > -  if (main) {
> > -    HandleEvent(e);
> > -  } else {
> > -    CHECK_EQ(atomic_load(&event, memory_order_relaxed), 0);
> > -    atomic_store(&event, (uintptr_t)e, memory_order_release);
> > -    while (atomic_load(&event, memory_order_acquire) != 0)
> > -      pthread_yield();
> > -  }
> > -}
> > -
> > -ScopedThread::ScopedThread(bool detached, bool main) {
> > -  impl_ = new Impl;
> > -  impl_->main = main;
> > -  impl_->detached = detached;
> > -  atomic_store(&impl_->event, 0, memory_order_relaxed);
> > -  if (!main) {
> > -    pthread_attr_t attr;
> > -    pthread_attr_init(&attr);
> > -    pthread_attr_setdetachstate(&attr, detached);
> > -    pthread_attr_setstacksize(&attr, 64*1024);
> > -    pthread_create(&impl_->thread, &attr,
> > -        ScopedThread::Impl::ScopedThreadCallback, impl_);
> > -  }
> > -}
> > -
> > -ScopedThread::~ScopedThread() {
> > -  if (!impl_->main) {
> > -    Event event(Event::SHUTDOWN);
> > -    impl_->send(&event);
> > -    if (!impl_->detached)
> > -      pthread_join(impl_->thread, 0);
> > -  }
> > -  delete impl_;
> > -}
> > -
> > -void ScopedThread::Detach() {
> > -  CHECK(!impl_->main);
> > -  CHECK(!impl_->detached);
> > -  impl_->detached = true;
> > -  pthread_detach(impl_->thread);
> > -}
> > -
> > -void ScopedThread::Access(void *addr, bool is_write,
> > -                          int size, bool expect_race) {
> > -  Event event(is_write ? Event::WRITE : Event::READ, addr, size);
> > -  if (expect_race)
> > -    event.ExpectReport(ReportTypeRace);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::VptrUpdate(const MemLoc &vptr,
> > -                              const MemLoc &new_val,
> > -                              bool expect_race) {
> > -  Event event(Event::VPTR_UPDATE, vptr.loc(), (uptr)new_val.loc());
> > -  if (expect_race)
> > -    event.ExpectReport(ReportTypeRace);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::Call(void(*pc)()) {
> > -  Event event(Event::CALL, (void*)pc);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::Return() {
> > -  Event event(Event::RETURN);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::Create(const Mutex &m) {
> > -  Event event(Event::MUTEX_CREATE, &m);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::Destroy(const Mutex &m) {
> > -  Event event(Event::MUTEX_DESTROY, &m);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::Lock(const Mutex &m) {
> > -  Event event(Event::MUTEX_LOCK, &m);
> > -  impl_->send(&event);
> > -}
> > -
> > -bool ScopedThread::TryLock(const Mutex &m) {
> > -  Event event(Event::MUTEX_TRYLOCK, &m);
> > -  impl_->send(&event);
> > -  return event.res;
> > -}
> > -
> > -void ScopedThread::Unlock(const Mutex &m) {
> > -  Event event(Event::MUTEX_UNLOCK, &m);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::ReadLock(const Mutex &m) {
> > -  Event event(Event::MUTEX_READLOCK, &m);
> > -  impl_->send(&event);
> > -}
> > -
> > -bool ScopedThread::TryReadLock(const Mutex &m) {
> > -  Event event(Event::MUTEX_TRYREADLOCK, &m);
> > -  impl_->send(&event);
> > -  return event.res;
> > -}
> > -
> > -void ScopedThread::ReadUnlock(const Mutex &m) {
> > -  Event event(Event::MUTEX_READUNLOCK, &m);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::Memcpy(void *dst, const void *src, int size,
> > -                          bool expect_race) {
> > -  Event event(Event::MEMCPY, dst, (uptr)src, size);
> > -  if (expect_race)
> > -    event.ExpectReport(ReportTypeRace);
> > -  impl_->send(&event);
> > -}
> > -
> > -void ScopedThread::Memset(void *dst, int val, int size,
> > -                          bool expect_race) {
> > -  Event event(Event::MEMSET, dst, val, size);
> > -  if (expect_race)
> > -    event.ExpectReport(ReportTypeRace);
> > -  impl_->send(&event);
> > -}
> >
> > Removed: compiler-rt/trunk/lib/tsan/rtl_tests/tsan_thread.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/rtl_tests/tsan_thread.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/rtl_tests/tsan_thread.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/rtl_tests/tsan_thread.cc (removed)
> > @@ -1,59 +0,0 @@
> > -//===-- tsan_thread.cc
> ----------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_test_util.h"
> > -#include "gtest/gtest.h"
> > -
> > -TEST(ThreadSanitizer, ThreadSync) {
> > -  MainThread t0;
> > -  MemLoc l;
> > -  t0.Write1(l);
> > -  {
> > -    ScopedThread t1;
> > -    t1.Write1(l);
> > -  }
> > -  t0.Write1(l);
> > -}
> > -
> > -TEST(ThreadSanitizer, ThreadDetach1) {
> > -  ScopedThread t1(true);
> > -  MemLoc l;
> > -  t1.Write1(l);
> > -}
> > -
> > -TEST(ThreadSanitizer, ThreadDetach2) {
> > -  ScopedThread t1;
> > -  MemLoc l;
> > -  t1.Write1(l);
> > -  t1.Detach();
> > -}
> > -
> > -static void *thread_alot_func(void *arg) {
> > -  (void)arg;
> > -  int usleep(unsigned);
> > -  usleep(50);
> > -  return 0;
> > -}
> > -
> > -TEST(DISABLED_SLOW_ThreadSanitizer, ThreadALot) {
> > -  const int kThreads = 70000;
> > -  const int kAlive = 1000;
> > -  pthread_t threads[kAlive] = {};
> > -  for (int i = 0; i < kThreads; i++) {
> > -    if (threads[i % kAlive])
> > -      pthread_join(threads[i % kAlive], 0);
> > -    pthread_create(&threads[i % kAlive], 0, thread_alot_func, 0);
> > -  }
> > -  for (int i = 0; i < kAlive; i++) {
> > -    pthread_join(threads[i], 0);
> > -  }
> > -}
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/CMakeLists.txt?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/CMakeLists.txt (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/CMakeLists.txt Mon Sep 17 05:02:17
> 2012
> > @@ -0,0 +1,24 @@
> > +include_directories(../rtl)
> > +
> > +add_custom_target(TsanUnitTests)
> > +set_target_properties(TsanUnitTests PROPERTIES
> > +  FOLDER "TSan unittests")
> > +function(add_tsan_unittest testname)
> > +  # Build unit tests only on 64-bit Linux.
> > +  if(UNIX AND NOT APPLE
> > +      AND CAN_TARGET_X86_64
> > +      AND CMAKE_SIZEOF_VOID_P EQUAL 8
> > +      AND NOT LLVM_BUILD_32_BITS)
> > +    add_unittest(TsanUnitTests ${testname} ${ARGN})
> > +    # Link with TSan runtime.
> > +    target_link_libraries(${testname} clang_rt.tsan-x86_64)
> > +    # Build tests with PIE and debug info.
> > +    set_property(TARGET ${testname} APPEND_STRING
> > +      PROPERTY COMPILE_FLAGS " -fPIE -g")
> > +    set_property(TARGET ${testname} APPEND_STRING
> > +      PROPERTY LINK_FLAGS " -pie")
> > +  endif()
> > +endfunction()
> > +
> > +add_subdirectory(rtl)
> > +add_subdirectory(unit)
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/CMakeLists.txt?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/CMakeLists.txt (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/CMakeLists.txt Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,15 @@
> > +set(TSAN_RTL_TESTS
> > +  tsan_bench.cc
> > +  tsan_mop.cc
> > +  tsan_mutex.cc
> > +  tsan_posix.cc
> > +  tsan_string.cc
> > +  tsan_test.cc
> > +  tsan_thread.cc
> > +  )
> > +
> > +if(UNIX AND NOT APPLE)
> > +  list(APPEND TSAN_RTL_TESTS tsan_test_util_linux.cc)
> > +endif()
> > +
> > +add_tsan_unittest(TsanRtlTest ${TSAN_RTL_TESTS})
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_bench.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_bench.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_bench.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_bench.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,105 @@
> > +//===-- tsan_bench.cc
> -----------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_test_util.h"
> > +#include "tsan_interface.h"
> > +#include "tsan_defs.h"
> > +#include "gtest/gtest.h"
> > +#include <stdint.h>
> > +
> > +const int kSize = 128;
> > +const int kRepeat = 2*1024*1024;
> > +
> > +void noinstr(void *p) {}
> > +
> > +template<typename T, void(*__tsan_mop)(void *p)>
> > +static void Benchmark() {
> > +  volatile T data[kSize];
> > +  for (int i = 0; i < kRepeat; i++) {
> > +    for (int j = 0; j < kSize; j++) {
> > +      __tsan_mop((void*)&data[j]);
> > +      data[j]++;
> > +    }
> > +  }
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop1) {
> > +  Benchmark<uint8_t, noinstr>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop1Read) {
> > +  Benchmark<uint8_t, __tsan_read1>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop1Write) {
> > +  Benchmark<uint8_t, __tsan_write1>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop2) {
> > +  Benchmark<uint16_t, noinstr>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop2Read) {
> > +  Benchmark<uint16_t, __tsan_read2>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop2Write) {
> > +  Benchmark<uint16_t, __tsan_write2>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop4) {
> > +  Benchmark<uint32_t, noinstr>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop4Read) {
> > +  Benchmark<uint32_t, __tsan_read4>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop4Write) {
> > +  Benchmark<uint32_t, __tsan_write4>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop8) {
> > +  Benchmark<uint8_t, noinstr>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop8Read) {
> > +  Benchmark<uint64_t, __tsan_read8>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, Mop8Write) {
> > +  Benchmark<uint64_t, __tsan_write8>();
> > +}
> > +
> > +TEST(DISABLED_BENCH, FuncCall) {
> > +  for (int i = 0; i < kRepeat; i++) {
> > +    for (int j = 0; j < kSize; j++)
> > +      __tsan_func_entry((void*)(uintptr_t)j);
> > +    for (int j = 0; j < kSize; j++)
> > +      __tsan_func_exit();
> > +  }
> > +}
> > +
> > +TEST(DISABLED_BENCH, MutexLocal) {
> > +  Mutex m;
> > +  ScopedThread().Create(m);
> > +  for (int i = 0; i < 50; i++) {
> > +    ScopedThread t;
> > +    t.Lock(m);
> > +    t.Unlock(m);
> > +  }
> > +  for (int i = 0; i < 16*1024*1024; i++) {
> > +    m.Lock();
> > +    m.Unlock();
> > +  }
> > +  ScopedThread().Destroy(m);
> > +}
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mop.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mop.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mop.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mop.cc Mon Sep 17 05:02:17
> 2012
> > @@ -0,0 +1,233 @@
> > +//===-- tsan_mop.cc
> -------------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_interface.h"
> > +#include "tsan_test_util.h"
> > +#include "gtest/gtest.h"
> > +#include <stddef.h>
> > +#include <stdint.h>
> > +
> > +TEST(ThreadSanitizer, SimpleWrite) {
> > +  ScopedThread t;
> > +  MemLoc l;
> > +  t.Write1(l);
> > +}
> > +
> > +TEST(ThreadSanitizer, SimpleWriteWrite) {
> > +  ScopedThread t1, t2;
> > +  MemLoc l1, l2;
> > +  t1.Write1(l1);
> > +  t2.Write1(l2);
> > +}
> > +
> > +TEST(ThreadSanitizer, WriteWriteRace) {
> > +  ScopedThread t1, t2;
> > +  MemLoc l;
> > +  t1.Write1(l);
> > +  t2.Write1(l, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, ReadWriteRace) {
> > +  ScopedThread t1, t2;
> > +  MemLoc l;
> > +  t1.Read1(l);
> > +  t2.Write1(l, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, WriteReadRace) {
> > +  ScopedThread t1, t2;
> > +  MemLoc l;
> > +  t1.Write1(l);
> > +  t2.Read1(l, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, ReadReadNoRace) {
> > +  ScopedThread t1, t2;
> > +  MemLoc l;
> > +  t1.Read1(l);
> > +  t2.Read1(l);
> > +}
> > +
> > +TEST(ThreadSanitizer, WriteThenRead) {
> > +  MemLoc l;
> > +  ScopedThread t1, t2;
> > +  t1.Write1(l);
> > +  t1.Read1(l);
> > +  t2.Read1(l, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, WriteThenLockedRead) {
> > +  Mutex m(Mutex::RW);
> > +  MainThread t0;
> > +  t0.Create(m);
> > +  MemLoc l;
> > +  {
> > +    ScopedThread t1, t2;
> > +
> > +    t1.Write8(l);
> > +
> > +    t1.Lock(m);
> > +    t1.Read8(l);
> > +    t1.Unlock(m);
> > +
> > +    t2.Read8(l, true);
> > +  }
> > +  t0.Destroy(m);
> > +}
> > +
> > +TEST(ThreadSanitizer, LockedWriteThenRead) {
> > +  Mutex m(Mutex::RW);
> > +  MainThread t0;
> > +  t0.Create(m);
> > +  MemLoc l;
> > +  {
> > +    ScopedThread t1, t2;
> > +
> > +    t1.Lock(m);
> > +    t1.Write8(l);
> > +    t1.Unlock(m);
> > +
> > +    t1.Read8(l);
> > +
> > +    t2.Read8(l, true);
> > +  }
> > +  t0.Destroy(m);
> > +}
> > +
> > +
> > +TEST(ThreadSanitizer, RaceWithOffset) {
> > +  ScopedThread t1, t2;
> > +  {
> > +    MemLoc l;
> > +    t1.Access(l.loc(), true, 8, false);
> > +    t2.Access((char*)l.loc() + 4, true, 4, true);
> > +  }
> > +  {
> > +    MemLoc l;
> > +    t1.Access(l.loc(), true, 8, false);
> > +    t2.Access((char*)l.loc() + 7, true, 1, true);
> > +  }
> > +  {
> > +    MemLoc l;
> > +    t1.Access((char*)l.loc() + 4, true, 4, false);
> > +    t2.Access((char*)l.loc() + 4, true, 2, true);
> > +  }
> > +  {
> > +    MemLoc l;
> > +    t1.Access((char*)l.loc() + 4, true, 4, false);
> > +    t2.Access((char*)l.loc() + 6, true, 2, true);
> > +  }
> > +  {
> > +    MemLoc l;
> > +    t1.Access((char*)l.loc() + 3, true, 2, false);
> > +    t2.Access((char*)l.loc() + 4, true, 1, true);
> > +  }
> > +  {
> > +    MemLoc l;
> > +    t1.Access((char*)l.loc() + 1, true, 8, false);
> > +    t2.Access((char*)l.loc() + 3, true, 1, true);
> > +  }
> > +}
> > +
> > +TEST(ThreadSanitizer, RaceWithOffset2) {
> > +  ScopedThread t1, t2;
> > +  {
> > +    MemLoc l;
> > +    t1.Access((char*)l.loc(), true, 4, false);
> > +    t2.Access((char*)l.loc() + 2, true, 1, true);
> > +  }
> > +  {
> > +    MemLoc l;
> > +    t1.Access((char*)l.loc() + 2, true, 1, false);
> > +    t2.Access((char*)l.loc(), true, 4, true);
> > +  }
> > +}
> > +
> > +TEST(ThreadSanitizer, NoRaceWithOffset) {
> > +  ScopedThread t1, t2;
> > +  {
> > +    MemLoc l;
> > +    t1.Access(l.loc(), true, 4, false);
> > +    t2.Access((char*)l.loc() + 4, true, 4, false);
> > +  }
> > +  {
> > +    MemLoc l;
> > +    t1.Access((char*)l.loc() + 3, true, 2, false);
> > +    t2.Access((char*)l.loc() + 1, true, 2, false);
> > +    t2.Access((char*)l.loc() + 5, true, 2, false);
> > +  }
> > +}
> > +
> > +TEST(ThreadSanitizer, RaceWithDeadThread) {
> > +  MemLoc l;
> > +  ScopedThread t;
> > +  ScopedThread().Write1(l);
> > +  t.Write1(l, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, BenignRaceOnVptr) {
> > +  void *vptr_storage;
> > +  MemLoc vptr(&vptr_storage), val;
> > +  vptr_storage = val.loc();
> > +  ScopedThread t1, t2;
> > +  t1.VptrUpdate(vptr, val);
> > +  t2.Read8(vptr);
> > +}
> > +
> > +TEST(ThreadSanitizer, HarmfulRaceOnVptr) {
> > +  void *vptr_storage;
> > +  MemLoc vptr(&vptr_storage), val1, val2;
> > +  vptr_storage = val1.loc();
> > +  ScopedThread t1, t2;
> > +  t1.VptrUpdate(vptr, val2);
> > +  t2.Read8(vptr, true);
> > +}
> > +
> > +static void foo() {
> > +  volatile int x = 42;
> > +  int x2 = x;
> > +  (void)x2;
> > +}
> > +
> > +static void bar() {
> > +  volatile int x = 43;
> > +  int x2 = x;
> > +  (void)x2;
> > +}
> > +
> > +TEST(ThreadSanitizer, ReportDeadThread) {
> > +  MemLoc l;
> > +  ScopedThread t1;
> > +  {
> > +    ScopedThread t2;
> > +    t2.Call(&foo);
> > +    t2.Call(&bar);
> > +    t2.Write1(l);
> > +  }
> > +  t1.Write1(l, true);
> > +}
> > +
> > +struct ClassWithStatic {
> > +  static int Data[4];
> > +};
> > +
> > +int ClassWithStatic::Data[4];
> > +
> > +static void foobarbaz() {}
> > +
> > +TEST(ThreadSanitizer, ReportRace) {
> > +  ScopedThread t1;
> > +  MainThread().Access(&ClassWithStatic::Data, true, 4, false);
> > +  t1.Call(&foobarbaz);
> > +  t1.Access(&ClassWithStatic::Data, true, 2, true);
> > +  t1.Return();
> > +}
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mutex.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mutex.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mutex.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_mutex.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,221 @@
> > +//===-- tsan_mutex.cc
> -----------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "sanitizer_common/sanitizer_atomic.h"
> > +#include "tsan_interface.h"
> > +#include "tsan_interface_ann.h"
> > +#include "tsan_test_util.h"
> > +#include "gtest/gtest.h"
> > +#include <stdint.h>
> > +
> > +namespace __tsan {
> > +
> > +TEST(ThreadSanitizer, BasicMutex) {
> > +  ScopedThread t;
> > +  Mutex m;
> > +  t.Create(m);
> > +
> > +  t.Lock(m);
> > +  t.Unlock(m);
> > +
> > +  CHECK(t.TryLock(m));
> > +  t.Unlock(m);
> > +
> > +  t.Lock(m);
> > +  CHECK(!t.TryLock(m));
> > +  t.Unlock(m);
> > +
> > +  t.Destroy(m);
> > +}
> > +
> > +TEST(ThreadSanitizer, BasicSpinMutex) {
> > +  ScopedThread t;
> > +  Mutex m(Mutex::Spin);
> > +  t.Create(m);
> > +
> > +  t.Lock(m);
> > +  t.Unlock(m);
> > +
> > +  CHECK(t.TryLock(m));
> > +  t.Unlock(m);
> > +
> > +  t.Lock(m);
> > +  CHECK(!t.TryLock(m));
> > +  t.Unlock(m);
> > +
> > +  t.Destroy(m);
> > +}
> > +
> > +TEST(ThreadSanitizer, BasicRwMutex) {
> > +  ScopedThread t;
> > +  Mutex m(Mutex::RW);
> > +  t.Create(m);
> > +
> > +  t.Lock(m);
> > +  t.Unlock(m);
> > +
> > +  CHECK(t.TryLock(m));
> > +  t.Unlock(m);
> > +
> > +  t.Lock(m);
> > +  CHECK(!t.TryLock(m));
> > +  t.Unlock(m);
> > +
> > +  t.ReadLock(m);
> > +  t.ReadUnlock(m);
> > +
> > +  CHECK(t.TryReadLock(m));
> > +  t.ReadUnlock(m);
> > +
> > +  t.Lock(m);
> > +  CHECK(!t.TryReadLock(m));
> > +  t.Unlock(m);
> > +
> > +  t.ReadLock(m);
> > +  CHECK(!t.TryLock(m));
> > +  t.ReadUnlock(m);
> > +
> > +  t.ReadLock(m);
> > +  CHECK(t.TryReadLock(m));
> > +  t.ReadUnlock(m);
> > +  t.ReadUnlock(m);
> > +
> > +  t.Destroy(m);
> > +}
> > +
> > +TEST(ThreadSanitizer, Mutex) {
> > +  Mutex m;
> > +  MainThread t0;
> > +  t0.Create(m);
> > +
> > +  ScopedThread t1, t2;
> > +  MemLoc l;
> > +  t1.Lock(m);
> > +  t1.Write1(l);
> > +  t1.Unlock(m);
> > +  t2.Lock(m);
> > +  t2.Write1(l);
> > +  t2.Unlock(m);
> > +  t2.Destroy(m);
> > +}
> > +
> > +TEST(ThreadSanitizer, SpinMutex) {
> > +  Mutex m(Mutex::Spin);
> > +  MainThread t0;
> > +  t0.Create(m);
> > +
> > +  ScopedThread t1, t2;
> > +  MemLoc l;
> > +  t1.Lock(m);
> > +  t1.Write1(l);
> > +  t1.Unlock(m);
> > +  t2.Lock(m);
> > +  t2.Write1(l);
> > +  t2.Unlock(m);
> > +  t2.Destroy(m);
> > +}
> > +
> > +TEST(ThreadSanitizer, RwMutex) {
> > +  Mutex m(Mutex::RW);
> > +  MainThread t0;
> > +  t0.Create(m);
> > +
> > +  ScopedThread t1, t2, t3;
> > +  MemLoc l;
> > +  t1.Lock(m);
> > +  t1.Write1(l);
> > +  t1.Unlock(m);
> > +  t2.Lock(m);
> > +  t2.Write1(l);
> > +  t2.Unlock(m);
> > +  t1.ReadLock(m);
> > +  t3.ReadLock(m);
> > +  t1.Read1(l);
> > +  t3.Read1(l);
> > +  t1.ReadUnlock(m);
> > +  t3.ReadUnlock(m);
> > +  t2.Lock(m);
> > +  t2.Write1(l);
> > +  t2.Unlock(m);
> > +  t2.Destroy(m);
> > +}
> > +
> > +TEST(ThreadSanitizer, StaticMutex) {
> > +  // Emulates statically initialized mutex.
> > +  Mutex m;
> > +  m.StaticInit();
> > +  {
> > +    ScopedThread t1, t2;
> > +    t1.Lock(m);
> > +    t1.Unlock(m);
> > +    t2.Lock(m);
> > +    t2.Unlock(m);
> > +  }
> > +  MainThread().Destroy(m);
> > +}
> > +
> > +static void *singleton_thread(void *param) {
> > +  atomic_uintptr_t *singleton = (atomic_uintptr_t *)param;
> > +  for (int i = 0; i < 4*1024*1024; i++) {
> > +    int *val = (int *)atomic_load(singleton, memory_order_acquire);
> > +    __tsan_acquire(singleton);
> > +    __tsan_read4(val);
> > +    CHECK_EQ(*val, 42);
> > +  }
> > +  return 0;
> > +}
> > +
> > +TEST(DISABLED_BENCH_ThreadSanitizer, Singleton) {
> > +  const int kClockSize = 100;
> > +  const int kThreadCount = 8;
> > +
> > +  // Puff off thread's clock.
> > +  for (int i = 0; i < kClockSize; i++) {
> > +    ScopedThread t1;
> > +    (void)t1;
> > +  }
> > +  // Create the singleton.
> > +  int val = 42;
> > +  __tsan_write4(&val);
> > +  atomic_uintptr_t singleton;
> > +  __tsan_release(&singleton);
> > +  atomic_store(&singleton, (uintptr_t)&val, memory_order_release);
> > +  // Create reader threads.
> > +  pthread_t threads[kThreadCount];
> > +  for (int t = 0; t < kThreadCount; t++)
> > +    pthread_create(&threads[t], 0, singleton_thread, &singleton);
> > +  for (int t = 0; t < kThreadCount; t++)
> > +    pthread_join(threads[t], 0);
> > +}
> > +
> > +TEST(DISABLED_BENCH_ThreadSanitizer, StopFlag) {
> > +  const int kClockSize = 100;
> > +  const int kIters = 16*1024*1024;
> > +
> > +  // Puff off thread's clock.
> > +  for (int i = 0; i < kClockSize; i++) {
> > +    ScopedThread t1;
> > +    (void)t1;
> > +  }
> > +  // Create the stop flag.
> > +  atomic_uintptr_t flag;
> > +  __tsan_release(&flag);
> > +  atomic_store(&flag, 0, memory_order_release);
> > +  // Read it a lot.
> > +  for (int i = 0; i < kIters; i++) {
> > +    uptr v = atomic_load(&flag, memory_order_acquire);
> > +    __tsan_acquire(&flag);
> > +    CHECK_EQ(v, 0);
> > +  }
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_posix.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_posix.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_posix.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_posix.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,146 @@
> > +//===-- tsan_posix.cc
> -----------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_interface.h"
> > +#include "tsan_test_util.h"
> > +#include "gtest/gtest.h"
> > +#include <pthread.h>
> > +
> > +struct thread_key {
> > +  pthread_key_t key;
> > +  pthread_mutex_t *mtx;
> > +  int val;
> > +  int *cnt;
> > +  thread_key(pthread_key_t key, pthread_mutex_t *mtx, int val, int *cnt)
> > +    : key(key)
> > +    , mtx(mtx)
> > +    , val(val)
> > +    , cnt(cnt) {
> > +  }
> > +};
> > +
> > +static void thread_secific_dtor(void *v) {
> > +  thread_key *k = (thread_key *)v;
> > +  EXPECT_EQ(pthread_mutex_lock(k->mtx), 0);
> > +  (*k->cnt)++;
> > +  __tsan_write4(&k->cnt);
> > +  EXPECT_EQ(pthread_mutex_unlock(k->mtx), 0);
> > +  if (k->val == 42) {
> > +    delete k;
> > +  } else if (k->val == 43 || k->val == 44) {
> > +    k->val--;
> > +    EXPECT_EQ(pthread_setspecific(k->key, k), 0);
> > +  } else {
> > +    ASSERT_TRUE(false);
> > +  }
> > +}
> > +
> > +static void *dtors_thread(void *p) {
> > +  thread_key *k = (thread_key *)p;
> > +  EXPECT_EQ(pthread_setspecific(k->key, k), 0);
> > +  return 0;
> > +}
> > +
> > +TEST(Posix, ThreadSpecificDtors) {
> > +  int cnt = 0;
> > +  pthread_key_t key;
> > +  EXPECT_EQ(pthread_key_create(&key, thread_secific_dtor), 0);
> > +  pthread_mutex_t mtx;
> > +  EXPECT_EQ(pthread_mutex_init(&mtx, 0), 0);
> > +  pthread_t th[3];
> > +  thread_key *k[3];
> > +  k[0] = new thread_key(key, &mtx, 42, &cnt);
> > +  k[1] = new thread_key(key, &mtx, 43, &cnt);
> > +  k[2] = new thread_key(key, &mtx, 44, &cnt);
> > +  EXPECT_EQ(pthread_create(&th[0], 0, dtors_thread, k[0]), 0);
> > +  EXPECT_EQ(pthread_create(&th[1], 0, dtors_thread, k[1]), 0);
> > +  EXPECT_EQ(pthread_join(th[0], 0), 0);
> > +  EXPECT_EQ(pthread_create(&th[2], 0, dtors_thread, k[2]), 0);
> > +  EXPECT_EQ(pthread_join(th[1], 0), 0);
> > +  EXPECT_EQ(pthread_join(th[2], 0), 0);
> > +  EXPECT_EQ(pthread_key_delete(key), 0);
> > +  EXPECT_EQ(6, cnt);
> > +}
> > +
> > +static __thread int local_var;
> > +
> > +static void *local_thread(void *p) {
> > +  __tsan_write1(&local_var);
> > +  __tsan_write1(&p);
> > +  if (p == 0)
> > +    return 0;
> > +  const int kThreads = 4;
> > +  pthread_t th[kThreads];
> > +  for (int i = 0; i < kThreads; i++)
> > +    EXPECT_EQ(pthread_create(&th[i], 0, local_thread,
> > +              (void*)((long)p - 1)), 0);  // NOLINT
> > +  for (int i = 0; i < kThreads; i++)
> > +    EXPECT_EQ(pthread_join(th[i], 0), 0);
> > +  return 0;
> > +}
> > +
> > +TEST(Posix, ThreadLocalAccesses) {
> > +  local_thread((void*)2);
> > +}
> > +
> > +struct CondContext {
> > +  pthread_mutex_t m;
> > +  pthread_cond_t c;
> > +  int data;
> > +};
> > +
> > +static void *cond_thread(void *p) {
> > +  CondContext &ctx = *static_cast<CondContext*>(p);
> > +
> > +  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > +  EXPECT_EQ(ctx.data, 0);
> > +  ctx.data = 1;
> > +  EXPECT_EQ(pthread_cond_signal(&ctx.c), 0);
> > +  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > +
> > +  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > +  while (ctx.data != 2)
> > +    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
> > +  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > +
> > +  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > +  ctx.data = 3;
> > +  EXPECT_EQ(pthread_cond_broadcast(&ctx.c), 0);
> > +  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > +
> > +  return 0;
> > +}
> > +
> > +TEST(Posix, CondBasic) {
> > +  CondContext ctx;
> > +  EXPECT_EQ(pthread_mutex_init(&ctx.m, 0), 0);
> > +  EXPECT_EQ(pthread_cond_init(&ctx.c, 0), 0);
> > +  ctx.data = 0;
> > +  pthread_t th;
> > +  EXPECT_EQ(pthread_create(&th, 0, cond_thread, &ctx), 0);
> > +
> > +  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > +  while (ctx.data != 1)
> > +    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
> > +  ctx.data = 2;
> > +  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > +  EXPECT_EQ(pthread_cond_broadcast(&ctx.c), 0);
> > +
> > +  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
> > +  while (ctx.data != 3)
> > +    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
> > +  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
> > +
> > +  EXPECT_EQ(pthread_join(th, 0), 0);
> > +  EXPECT_EQ(pthread_cond_destroy(&ctx.c), 0);
> > +  EXPECT_EQ(pthread_mutex_destroy(&ctx.m), 0);
> > +}
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_string.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_string.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_string.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_string.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,82 @@
> > +//===-- tsan_string.cc
> ----------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_test_util.h"
> > +#include "gtest/gtest.h"
> > +#include <string.h>
> > +
> > +namespace __tsan {
> > +
> > +TEST(ThreadSanitizer, Memcpy) {
> > +  char data0[7] = {1, 2, 3, 4, 5, 6, 7};
> > +  char data[7] = {42, 42, 42, 42, 42, 42, 42};
> > +  MainThread().Memcpy(data+1, data0+1, 5);
> > +  EXPECT_EQ(data[0], 42);
> > +  EXPECT_EQ(data[1], 2);
> > +  EXPECT_EQ(data[2], 3);
> > +  EXPECT_EQ(data[3], 4);
> > +  EXPECT_EQ(data[4], 5);
> > +  EXPECT_EQ(data[5], 6);
> > +  EXPECT_EQ(data[6], 42);
> > +  MainThread().Memset(data+1, 13, 5);
> > +  EXPECT_EQ(data[0], 42);
> > +  EXPECT_EQ(data[1], 13);
> > +  EXPECT_EQ(data[2], 13);
> > +  EXPECT_EQ(data[3], 13);
> > +  EXPECT_EQ(data[4], 13);
> > +  EXPECT_EQ(data[5], 13);
> > +  EXPECT_EQ(data[6], 42);
> > +}
> > +
> > +TEST(ThreadSanitizer, MemcpyRace1) {
> > +  char *data = new char[10];
> > +  char *data1 = new char[10];
> > +  char *data2 = new char[10];
> > +  ScopedThread t1, t2;
> > +  t1.Memcpy(data, data1, 10);
> > +  t2.Memcpy(data, data2, 10, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, MemcpyRace2) {
> > +  char *data = new char[10];
> > +  char *data1 = new char[10];
> > +  char *data2 = new char[10];
> > +  ScopedThread t1, t2;
> > +  t1.Memcpy(data+5, data1, 1);
> > +  t2.Memcpy(data+3, data2, 4, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, MemcpyRace3) {
> > +  char *data = new char[10];
> > +  char *data1 = new char[10];
> > +  char *data2 = new char[10];
> > +  ScopedThread t1, t2;
> > +  t1.Memcpy(data, data1, 10);
> > +  t2.Memcpy(data1, data2, 10, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, MemcpyStack) {
> > +  char *data = new char[10];
> > +  char *data1 = new char[10];
> > +  ScopedThread t1, t2;
> > +  t1.Memcpy(data, data1, 10);
> > +  t2.Memcpy(data, data1, 10, true);
> > +}
> > +
> > +TEST(ThreadSanitizer, MemsetRace1) {
> > +  char *data = new char[10];
> > +  ScopedThread t1, t2;
> > +  t1.Memset(data, 1, 10);
> > +  t2.Memset(data, 2, 10, true);
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,44 @@
> > +//===-- tsan_test.cc
> ------------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_interface.h"
> > +#include "tsan_test_util.h"
> > +#include "gtest/gtest.h"
> > +
> > +static void foo() {}
> > +static void bar() {}
> > +
> > +TEST(ThreadSanitizer, FuncCall) {
> > +  ScopedThread t1, t2;
> > +  MemLoc l;
> > +  t1.Write1(l);
> > +  t2.Call(foo);
> > +  t2.Call(bar);
> > +  t2.Write1(l, true);
> > +  t2.Return();
> > +  t2.Return();
> > +}
> > +
> > +int main(int argc, char **argv) {
> > +  TestMutexBeforeInit();  // Mutexes must be usable before
> __tsan_init();
> > +  __tsan_init();
> > +  __tsan_func_entry(__builtin_return_address(0));
> > +  __tsan_func_entry((char*)&main + 1);
>
> This seems to break the CMake build:
>
> llvm/projects/compiler-rt/lib/tsan/tests/rtl/tsan_test.cc:35:21:
> error: cast between pointer-to-function and pointer-to-object is an
> extension [-Werror,-Wpedantic]
>   __tsan_func_entry((char*)&main + 1);
>                     ^~~~~~~~~~~~
> 1 error generated.
>
> I'm not sure what, if anything, is the right fix for this.
>
> > +
> > +  testing::GTEST_FLAG(death_test_style) = "threadsafe";
> > +  testing::InitGoogleTest(&argc, argv);
> > +  int res = RUN_ALL_TESTS();
> > +
> > +  __tsan_func_exit();
> > +  __tsan_func_exit();
> > +  return res;
> > +}
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util.h
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util.h?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util.h (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util.h Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,122 @@
> > +//===-- tsan_test_util.h ----------------------------------------*- C++
> -*-===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> > +// Test utils.
> >
> +//===----------------------------------------------------------------------===//
> > +#ifndef TSAN_TEST_UTIL_H
> > +#define TSAN_TEST_UTIL_H
> > +
> > +void TestMutexBeforeInit();
> > +
> > +// A location of memory on which a race may be detected.
> > +class MemLoc {
> > + public:
> > +  explicit MemLoc(int offset_from_aligned = 0);
> > +  explicit MemLoc(void *const real_addr) : loc_(real_addr) { }
> > +  ~MemLoc();
> > +  void *loc() const { return loc_; }
> > + private:
> > +  void *const loc_;
> > +  MemLoc(const MemLoc&);
> > +  void operator = (const MemLoc&);
> > +};
> > +
> > +class Mutex {
> > + public:
> > +  enum Type { Normal, Spin, RW };
> > +
> > +  explicit Mutex(Type type = Normal);
> > +  ~Mutex();
> > +
> > +  void Init();
> > +  void StaticInit();  // Emulates static initalization (tsan invisible).
> > +  void Destroy();
> > +  void Lock();
> > +  bool TryLock();
> > +  void Unlock();
> > +  void ReadLock();
> > +  bool TryReadLock();
> > +  void ReadUnlock();
> > +
> > + private:
> > +  // Placeholder for pthread_mutex_t, CRITICAL_SECTION or whatever.
> > +  void *mtx_[128];
> > +  bool alive_;
> > +  const Type type_;
> > +
> > +  Mutex(const Mutex&);
> > +  void operator = (const Mutex&);
> > +};
> > +
> > +// A thread is started in CTOR and joined in DTOR.
> > +class ScopedThread {
> > + public:
> > +  explicit ScopedThread(bool detached = false, bool main = false);
> > +  ~ScopedThread();
> > +  void Detach();
> > +
> > +  void Access(void *addr, bool is_write, int size, bool expect_race);
> > +  void Read(const MemLoc &ml, int size, bool expect_race = false) {
> > +    Access(ml.loc(), false, size, expect_race);
> > +  }
> > +  void Write(const MemLoc &ml, int size, bool expect_race = false) {
> > +    Access(ml.loc(), true, size, expect_race);
> > +  }
> > +  void Read1(const MemLoc &ml, bool expect_race = false) {
> > +    Read(ml, 1, expect_race); }
> > +  void Read2(const MemLoc &ml, bool expect_race = false) {
> > +    Read(ml, 2, expect_race); }
> > +  void Read4(const MemLoc &ml, bool expect_race = false) {
> > +    Read(ml, 4, expect_race); }
> > +  void Read8(const MemLoc &ml, bool expect_race = false) {
> > +    Read(ml, 8, expect_race); }
> > +  void Write1(const MemLoc &ml, bool expect_race = false) {
> > +    Write(ml, 1, expect_race); }
> > +  void Write2(const MemLoc &ml, bool expect_race = false) {
> > +    Write(ml, 2, expect_race); }
> > +  void Write4(const MemLoc &ml, bool expect_race = false) {
> > +    Write(ml, 4, expect_race); }
> > +  void Write8(const MemLoc &ml, bool expect_race = false) {
> > +    Write(ml, 8, expect_race); }
> > +
> > +  void VptrUpdate(const MemLoc &vptr, const MemLoc &new_val,
> > +                  bool expect_race = false);
> > +
> > +  void Call(void(*pc)());
> > +  void Return();
> > +
> > +  void Create(const Mutex &m);
> > +  void Destroy(const Mutex &m);
> > +  void Lock(const Mutex &m);
> > +  bool TryLock(const Mutex &m);
> > +  void Unlock(const Mutex &m);
> > +  void ReadLock(const Mutex &m);
> > +  bool TryReadLock(const Mutex &m);
> > +  void ReadUnlock(const Mutex &m);
> > +
> > +  void Memcpy(void *dst, const void *src, int size, bool expect_race =
> false);
> > +  void Memset(void *dst, int val, int size, bool expect_race = false);
> > +
> > + private:
> > +  struct Impl;
> > +  Impl *impl_;
> > +  ScopedThread(const ScopedThread&);  // Not implemented.
> > +  void operator = (const ScopedThread&);  // Not implemented.
> > +};
> > +
> > +class MainThread : public ScopedThread {
> > + public:
> > +  MainThread()
> > +    : ScopedThread(false, true) {
> > +  }
> > +};
> > +
> > +#endif  // #ifndef TSAN_TEST_UTIL_H
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util_linux.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util_linux.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util_linux.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util_linux.cc Mon Sep
> 17 05:02:17 2012
> > @@ -0,0 +1,465 @@
> > +
> > +//===-- tsan_test_util_linux.cc
> -------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> > +// Test utils, linux implementation.
> >
> +//===----------------------------------------------------------------------===//
> > +
> > +#include "sanitizer_common/sanitizer_atomic.h"
> > +#include "tsan_interface.h"
> > +#include "tsan_test_util.h"
> > +#include "tsan_report.h"
> > +
> > +#include "gtest/gtest.h"
> > +
> > +#include <assert.h>
> > +#include <pthread.h>
> > +#include <stdio.h>
> > +#include <stdint.h>
> > +#include <string.h>
> > +#include <unistd.h>
> > +#include <errno.h>
> > +
> > +using namespace __tsan;  // NOLINT
> > +
> > +static __thread bool expect_report;
> > +static __thread bool expect_report_reported;
> > +static __thread ReportType expect_report_type;
> > +
> > +extern "C" void *__interceptor_memcpy(void*, const void*, uptr);
> > +extern "C" void *__interceptor_memset(void*, int, uptr);
> > +
> > +static void *BeforeInitThread(void *param) {
> > +  (void)param;
> > +  return 0;
> > +}
> > +
> > +static void AtExit() {
> > +}
> > +
> > +void TestMutexBeforeInit() {
> > +  // Mutexes must be usable before __tsan_init();
> > +  pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
> > +  pthread_mutex_lock(&mtx);
> > +  pthread_mutex_unlock(&mtx);
> > +  pthread_mutex_destroy(&mtx);
> > +  pthread_t thr;
> > +  pthread_create(&thr, 0, BeforeInitThread, 0);
> > +  pthread_join(thr, 0);
> > +  atexit(AtExit);
> > +}
> > +
> > +namespace __tsan {
> > +bool OnReport(const ReportDesc *rep, bool suppressed) {
> > +  if (expect_report) {
> > +    if (rep->typ != expect_report_type) {
> > +      printf("Expected report of type %d, got type %d\n",
> > +             (int)expect_report_type, (int)rep->typ);
> > +      EXPECT_FALSE("Wrong report type");
> > +      return false;
> > +    }
> > +  } else {
> > +    EXPECT_FALSE("Unexpected report");
> > +    return false;
> > +  }
> > +  expect_report_reported = true;
> > +  return true;
> > +}
> > +}
> > +
> > +static void* allocate_addr(int size, int offset_from_aligned = 0) {
> > +  static uintptr_t foo;
> > +  static atomic_uintptr_t uniq = {(uintptr_t)&foo};  // Some real
> address.
> > +  const int kAlign = 16;
> > +  CHECK(offset_from_aligned < kAlign);
> > +  size = (size + 2 * kAlign) & ~(kAlign - 1);
> > +  uintptr_t addr = atomic_fetch_add(&uniq, size, memory_order_relaxed);
> > +  return (void*)(addr + offset_from_aligned);
> > +}
> > +
> > +MemLoc::MemLoc(int offset_from_aligned)
> > +  : loc_(allocate_addr(16, offset_from_aligned)) {
> > +}
> > +
> > +MemLoc::~MemLoc() {
> > +}
> > +
> > +Mutex::Mutex(Type type)
> > +  : alive_()
> > +  , type_(type) {
> > +}
> > +
> > +Mutex::~Mutex() {
> > +  CHECK(!alive_);
> > +}
> > +
> > +void Mutex::Init() {
> > +  CHECK(!alive_);
> > +  alive_ = true;
> > +  if (type_ == Normal)
> > +    CHECK_EQ(pthread_mutex_init((pthread_mutex_t*)mtx_, 0), 0);
> > +  else if (type_ == Spin)
> > +    CHECK_EQ(pthread_spin_init((pthread_spinlock_t*)mtx_, 0), 0);
> > +  else if (type_ == RW)
> > +    CHECK_EQ(pthread_rwlock_init((pthread_rwlock_t*)mtx_, 0), 0);
> > +  else
> > +    CHECK(0);
> > +}
> > +
> > +void Mutex::StaticInit() {
> > +  CHECK(!alive_);
> > +  CHECK(type_ == Normal);
> > +  alive_ = true;
> > +  pthread_mutex_t tmp = PTHREAD_MUTEX_INITIALIZER;
> > +  memcpy(mtx_, &tmp, sizeof(tmp));
> > +}
> > +
> > +void Mutex::Destroy() {
> > +  CHECK(alive_);
> > +  alive_ = false;
> > +  if (type_ == Normal)
> > +    CHECK_EQ(pthread_mutex_destroy((pthread_mutex_t*)mtx_), 0);
> > +  else if (type_ == Spin)
> > +    CHECK_EQ(pthread_spin_destroy((pthread_spinlock_t*)mtx_), 0);
> > +  else if (type_ == RW)
> > +    CHECK_EQ(pthread_rwlock_destroy((pthread_rwlock_t*)mtx_), 0);
> > +}
> > +
> > +void Mutex::Lock() {
> > +  CHECK(alive_);
> > +  if (type_ == Normal)
> > +    CHECK_EQ(pthread_mutex_lock((pthread_mutex_t*)mtx_), 0);
> > +  else if (type_ == Spin)
> > +    CHECK_EQ(pthread_spin_lock((pthread_spinlock_t*)mtx_), 0);
> > +  else if (type_ == RW)
> > +    CHECK_EQ(pthread_rwlock_wrlock((pthread_rwlock_t*)mtx_), 0);
> > +}
> > +
> > +bool Mutex::TryLock() {
> > +  CHECK(alive_);
> > +  if (type_ == Normal)
> > +    return pthread_mutex_trylock((pthread_mutex_t*)mtx_) == 0;
> > +  else if (type_ == Spin)
> > +    return pthread_spin_trylock((pthread_spinlock_t*)mtx_) == 0;
> > +  else if (type_ == RW)
> > +    return pthread_rwlock_trywrlock((pthread_rwlock_t*)mtx_) == 0;
> > +  return false;
> > +}
> > +
> > +void Mutex::Unlock() {
> > +  CHECK(alive_);
> > +  if (type_ == Normal)
> > +    CHECK_EQ(pthread_mutex_unlock((pthread_mutex_t*)mtx_), 0);
> > +  else if (type_ == Spin)
> > +    CHECK_EQ(pthread_spin_unlock((pthread_spinlock_t*)mtx_), 0);
> > +  else if (type_ == RW)
> > +    CHECK_EQ(pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
> > +}
> > +
> > +void Mutex::ReadLock() {
> > +  CHECK(alive_);
> > +  CHECK(type_ == RW);
> > +  CHECK_EQ(pthread_rwlock_rdlock((pthread_rwlock_t*)mtx_), 0);
> > +}
> > +
> > +bool Mutex::TryReadLock() {
> > +  CHECK(alive_);
> > +  CHECK(type_ == RW);
> > +  return pthread_rwlock_tryrdlock((pthread_rwlock_t*)mtx_) ==  0;
> > +}
> > +
> > +void Mutex::ReadUnlock() {
> > +  CHECK(alive_);
> > +  CHECK(type_ == RW);
> > +  CHECK_EQ(pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
> > +}
> > +
> > +struct Event {
> > +  enum Type {
> > +    SHUTDOWN,
> > +    READ,
> > +    WRITE,
> > +    VPTR_UPDATE,
> > +    CALL,
> > +    RETURN,
> > +    MUTEX_CREATE,
> > +    MUTEX_DESTROY,
> > +    MUTEX_LOCK,
> > +    MUTEX_TRYLOCK,
> > +    MUTEX_UNLOCK,
> > +    MUTEX_READLOCK,
> > +    MUTEX_TRYREADLOCK,
> > +    MUTEX_READUNLOCK,
> > +    MEMCPY,
> > +    MEMSET
> > +  };
> > +  Type type;
> > +  void *ptr;
> > +  uptr arg;
> > +  uptr arg2;
> > +  bool res;
> > +  bool expect_report;
> > +  ReportType report_type;
> > +
> > +  Event(Type type, const void *ptr = 0, uptr arg = 0, uptr arg2 = 0)
> > +    : type(type)
> > +    , ptr(const_cast<void*>(ptr))
> > +    , arg(arg)
> > +    , arg2(arg2)
> > +    , res()
> > +    , expect_report()
> > +    , report_type() {
> > +  }
> > +
> > +  void ExpectReport(ReportType type) {
> > +    expect_report = true;
> > +    report_type = type;
> > +  }
> > +};
> > +
> > +struct ScopedThread::Impl {
> > +  pthread_t thread;
> > +  bool main;
> > +  bool detached;
> > +  atomic_uintptr_t event;  // Event*
> > +
> > +  static void *ScopedThreadCallback(void *arg);
> > +  void send(Event *ev);
> > +  void HandleEvent(Event *ev);
> > +};
> > +
> > +void ScopedThread::Impl::HandleEvent(Event *ev) {
> > +  CHECK_EQ(expect_report, false);
> > +  expect_report = ev->expect_report;
> > +  expect_report_reported = false;
> > +  expect_report_type = ev->report_type;
> > +  switch (ev->type) {
> > +  case Event::READ:
> > +  case Event::WRITE: {
> > +    void (*tsan_mop)(void *addr) = 0;
> > +    if (ev->type == Event::READ) {
> > +      switch (ev->arg /*size*/) {
> > +        case 1: tsan_mop = __tsan_read1; break;
> > +        case 2: tsan_mop = __tsan_read2; break;
> > +        case 4: tsan_mop = __tsan_read4; break;
> > +        case 8: tsan_mop = __tsan_read8; break;
> > +        case 16: tsan_mop = __tsan_read16; break;
> > +      }
> > +    } else {
> > +      switch (ev->arg /*size*/) {
> > +        case 1: tsan_mop = __tsan_write1; break;
> > +        case 2: tsan_mop = __tsan_write2; break;
> > +        case 4: tsan_mop = __tsan_write4; break;
> > +        case 8: tsan_mop = __tsan_write8; break;
> > +        case 16: tsan_mop = __tsan_write16; break;
> > +      }
> > +    }
> > +    CHECK_NE(tsan_mop, 0);
> > +    errno = ECHRNG;
> > +    tsan_mop(ev->ptr);
> > +    CHECK_EQ(errno, ECHRNG);  // In no case must errno be changed.
> > +    break;
> > +  }
> > +  case Event::VPTR_UPDATE:
> > +    __tsan_vptr_update((void**)ev->ptr, (void*)ev->arg);
> > +    break;
> > +  case Event::CALL:
> > +    __tsan_func_entry((void*)((uptr)ev->ptr));
> > +    break;
> > +  case Event::RETURN:
> > +    __tsan_func_exit();
> > +    break;
> > +  case Event::MUTEX_CREATE:
> > +    static_cast<Mutex*>(ev->ptr)->Init();
> > +    break;
> > +  case Event::MUTEX_DESTROY:
> > +    static_cast<Mutex*>(ev->ptr)->Destroy();
> > +    break;
> > +  case Event::MUTEX_LOCK:
> > +    static_cast<Mutex*>(ev->ptr)->Lock();
> > +    break;
> > +  case Event::MUTEX_TRYLOCK:
> > +    ev->res = static_cast<Mutex*>(ev->ptr)->TryLock();
> > +    break;
> > +  case Event::MUTEX_UNLOCK:
> > +    static_cast<Mutex*>(ev->ptr)->Unlock();
> > +    break;
> > +  case Event::MUTEX_READLOCK:
> > +    static_cast<Mutex*>(ev->ptr)->ReadLock();
> > +    break;
> > +  case Event::MUTEX_TRYREADLOCK:
> > +    ev->res = static_cast<Mutex*>(ev->ptr)->TryReadLock();
> > +    break;
> > +  case Event::MUTEX_READUNLOCK:
> > +    static_cast<Mutex*>(ev->ptr)->ReadUnlock();
> > +    break;
> > +  case Event::MEMCPY:
> > +    __interceptor_memcpy(ev->ptr, (void*)ev->arg, ev->arg2);
> > +    break;
> > +  case Event::MEMSET:
> > +    __interceptor_memset(ev->ptr, ev->arg, ev->arg2);
> > +    break;
> > +  default: CHECK(0);
> > +  }
> > +  if (expect_report && !expect_report_reported) {
> > +    printf("Missed expected report of type %d\n", (int)ev->report_type);
> > +    EXPECT_FALSE("Missed expected race");
> > +  }
> > +  expect_report = false;
> > +}
> > +
> > +void *ScopedThread::Impl::ScopedThreadCallback(void *arg) {
> > +  __tsan_func_entry(__builtin_return_address(0));
> > +  Impl *impl = (Impl*)arg;
> > +  for (;;) {
> > +    Event* ev = (Event*)atomic_load(&impl->event, memory_order_acquire);
> > +    if (ev == 0) {
> > +      pthread_yield();
> > +      continue;
> > +    }
> > +    if (ev->type == Event::SHUTDOWN) {
> > +      atomic_store(&impl->event, 0, memory_order_release);
> > +      break;
> > +    }
> > +    impl->HandleEvent(ev);
> > +    atomic_store(&impl->event, 0, memory_order_release);
> > +  }
> > +  __tsan_func_exit();
> > +  return 0;
> > +}
> > +
> > +void ScopedThread::Impl::send(Event *e) {
> > +  if (main) {
> > +    HandleEvent(e);
> > +  } else {
> > +    CHECK_EQ(atomic_load(&event, memory_order_relaxed), 0);
> > +    atomic_store(&event, (uintptr_t)e, memory_order_release);
> > +    while (atomic_load(&event, memory_order_acquire) != 0)
> > +      pthread_yield();
> > +  }
> > +}
> > +
> > +ScopedThread::ScopedThread(bool detached, bool main) {
> > +  impl_ = new Impl;
> > +  impl_->main = main;
> > +  impl_->detached = detached;
> > +  atomic_store(&impl_->event, 0, memory_order_relaxed);
> > +  if (!main) {
> > +    pthread_attr_t attr;
> > +    pthread_attr_init(&attr);
> > +    pthread_attr_setdetachstate(&attr, detached);
> > +    pthread_attr_setstacksize(&attr, 64*1024);
> > +    pthread_create(&impl_->thread, &attr,
> > +        ScopedThread::Impl::ScopedThreadCallback, impl_);
> > +  }
> > +}
> > +
> > +ScopedThread::~ScopedThread() {
> > +  if (!impl_->main) {
> > +    Event event(Event::SHUTDOWN);
> > +    impl_->send(&event);
> > +    if (!impl_->detached)
> > +      pthread_join(impl_->thread, 0);
> > +  }
> > +  delete impl_;
> > +}
> > +
> > +void ScopedThread::Detach() {
> > +  CHECK(!impl_->main);
> > +  CHECK(!impl_->detached);
> > +  impl_->detached = true;
> > +  pthread_detach(impl_->thread);
> > +}
> > +
> > +void ScopedThread::Access(void *addr, bool is_write,
> > +                          int size, bool expect_race) {
> > +  Event event(is_write ? Event::WRITE : Event::READ, addr, size);
> > +  if (expect_race)
> > +    event.ExpectReport(ReportTypeRace);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::VptrUpdate(const MemLoc &vptr,
> > +                              const MemLoc &new_val,
> > +                              bool expect_race) {
> > +  Event event(Event::VPTR_UPDATE, vptr.loc(), (uptr)new_val.loc());
> > +  if (expect_race)
> > +    event.ExpectReport(ReportTypeRace);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::Call(void(*pc)()) {
> > +  Event event(Event::CALL, (void*)pc);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::Return() {
> > +  Event event(Event::RETURN);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::Create(const Mutex &m) {
> > +  Event event(Event::MUTEX_CREATE, &m);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::Destroy(const Mutex &m) {
> > +  Event event(Event::MUTEX_DESTROY, &m);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::Lock(const Mutex &m) {
> > +  Event event(Event::MUTEX_LOCK, &m);
> > +  impl_->send(&event);
> > +}
> > +
> > +bool ScopedThread::TryLock(const Mutex &m) {
> > +  Event event(Event::MUTEX_TRYLOCK, &m);
> > +  impl_->send(&event);
> > +  return event.res;
> > +}
> > +
> > +void ScopedThread::Unlock(const Mutex &m) {
> > +  Event event(Event::MUTEX_UNLOCK, &m);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::ReadLock(const Mutex &m) {
> > +  Event event(Event::MUTEX_READLOCK, &m);
> > +  impl_->send(&event);
> > +}
> > +
> > +bool ScopedThread::TryReadLock(const Mutex &m) {
> > +  Event event(Event::MUTEX_TRYREADLOCK, &m);
> > +  impl_->send(&event);
> > +  return event.res;
> > +}
> > +
> > +void ScopedThread::ReadUnlock(const Mutex &m) {
> > +  Event event(Event::MUTEX_READUNLOCK, &m);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::Memcpy(void *dst, const void *src, int size,
> > +                          bool expect_race) {
> > +  Event event(Event::MEMCPY, dst, (uptr)src, size);
> > +  if (expect_race)
> > +    event.ExpectReport(ReportTypeRace);
> > +  impl_->send(&event);
> > +}
> > +
> > +void ScopedThread::Memset(void *dst, int val, int size,
> > +                          bool expect_race) {
> > +  Event event(Event::MEMSET, dst, val, size);
> > +  if (expect_race)
> > +    event.ExpectReport(ReportTypeRace);
> > +  impl_->send(&event);
> > +}
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/rtl/tsan_thread.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/rtl/tsan_thread.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/rtl/tsan_thread.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/rtl/tsan_thread.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,59 @@
> > +//===-- tsan_thread.cc
> ----------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_test_util.h"
> > +#include "gtest/gtest.h"
> > +
> > +TEST(ThreadSanitizer, ThreadSync) {
> > +  MainThread t0;
> > +  MemLoc l;
> > +  t0.Write1(l);
> > +  {
> > +    ScopedThread t1;
> > +    t1.Write1(l);
> > +  }
> > +  t0.Write1(l);
> > +}
> > +
> > +TEST(ThreadSanitizer, ThreadDetach1) {
> > +  ScopedThread t1(true);
> > +  MemLoc l;
> > +  t1.Write1(l);
> > +}
> > +
> > +TEST(ThreadSanitizer, ThreadDetach2) {
> > +  ScopedThread t1;
> > +  MemLoc l;
> > +  t1.Write1(l);
> > +  t1.Detach();
> > +}
> > +
> > +static void *thread_alot_func(void *arg) {
> > +  (void)arg;
> > +  int usleep(unsigned);
> > +  usleep(50);
> > +  return 0;
> > +}
> > +
> > +TEST(DISABLED_SLOW_ThreadSanitizer, ThreadALot) {
> > +  const int kThreads = 70000;
> > +  const int kAlive = 1000;
> > +  pthread_t threads[kAlive] = {};
> > +  for (int i = 0; i < kThreads; i++) {
> > +    if (threads[i % kAlive])
> > +      pthread_join(threads[i % kAlive], 0);
> > +    pthread_create(&threads[i % kAlive], 0, thread_alot_func, 0);
> > +  }
> > +  for (int i = 0; i < kAlive; i++) {
> > +    pthread_join(threads[i], 0);
> > +  }
> > +}
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/CMakeLists.txt?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/CMakeLists.txt (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/CMakeLists.txt Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,15 @@
> > +set(TSAN_UNIT_TESTS
> > +  tsan_clock_test.cc
> > +  tsan_flags_test.cc
> > +  tsan_mman_test.cc
> > +  tsan_mutex_test.cc
> > +  tsan_platform_test.cc
> > +  tsan_printf_test.cc
> > +  tsan_shadow_test.cc
> > +  tsan_stack_test.cc
> > +  tsan_suppressions_test.cc
> > +  tsan_sync_test.cc
> > +  tsan_vector_test.cc
> > +  )
> > +
> > +add_tsan_unittest(TsanUnitTest ${TSAN_UNIT_TESTS})
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_clock_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_clock_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_clock_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_clock_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,123 @@
> > +//===-- tsan_clock_test.cc
> ------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_clock.h"
> > +#include "tsan_rtl.h"
> > +#include "gtest/gtest.h"
> > +
> > +namespace __tsan {
> > +
> > +TEST(Clock, VectorBasic) {
> > +  ScopedInRtl in_rtl;
> > +  ThreadClock clk;
> > +  CHECK_EQ(clk.size(), 0);
> > +  clk.tick(0);
> > +  CHECK_EQ(clk.size(), 1);
> > +  CHECK_EQ(clk.get(0), 1);
> > +  clk.tick(3);
> > +  CHECK_EQ(clk.size(), 4);
> > +  CHECK_EQ(clk.get(0), 1);
> > +  CHECK_EQ(clk.get(1), 0);
> > +  CHECK_EQ(clk.get(2), 0);
> > +  CHECK_EQ(clk.get(3), 1);
> > +  clk.tick(3);
> > +  CHECK_EQ(clk.get(3), 2);
> > +}
> > +
> > +TEST(Clock, ChunkedBasic) {
> > +  ScopedInRtl in_rtl;
> > +  ThreadClock vector;
> > +  SyncClock chunked;
> > +  CHECK_EQ(vector.size(), 0);
> > +  CHECK_EQ(chunked.size(), 0);
> > +  vector.acquire(&chunked);
> > +  CHECK_EQ(vector.size(), 0);
> > +  CHECK_EQ(chunked.size(), 0);
> > +  vector.release(&chunked);
> > +  CHECK_EQ(vector.size(), 0);
> > +  CHECK_EQ(chunked.size(), 0);
> > +  vector.acq_rel(&chunked);
> > +  CHECK_EQ(vector.size(), 0);
> > +  CHECK_EQ(chunked.size(), 0);
> > +}
> > +
> > +TEST(Clock, AcquireRelease) {
> > +  ScopedInRtl in_rtl;
> > +  ThreadClock vector1;
> > +  vector1.tick(100);
> > +  SyncClock chunked;
> > +  vector1.release(&chunked);
> > +  CHECK_EQ(chunked.size(), 101);
> > +  ThreadClock vector2;
> > +  vector2.acquire(&chunked);
> > +  CHECK_EQ(vector2.size(), 101);
> > +  CHECK_EQ(vector2.get(0), 0);
> > +  CHECK_EQ(vector2.get(1), 0);
> > +  CHECK_EQ(vector2.get(99), 0);
> > +  CHECK_EQ(vector2.get(100), 1);
> > +}
> > +
> > +TEST(Clock, ManyThreads) {
> > +  ScopedInRtl in_rtl;
> > +  SyncClock chunked;
> > +  for (int i = 0; i < 100; i++) {
> > +    ThreadClock vector;
> > +    vector.tick(i);
> > +    vector.release(&chunked);
> > +    CHECK_EQ(chunked.size(), i + 1);
> > +    vector.acquire(&chunked);
> > +    CHECK_EQ(vector.size(), i + 1);
> > +  }
> > +  ThreadClock vector;
> > +  vector.acquire(&chunked);
> > +  CHECK_EQ(vector.size(), 100);
> > +  for (int i = 0; i < 100; i++)
> > +    CHECK_EQ(vector.get(i), 1);
> > +}
> > +
> > +TEST(Clock, DifferentSizes) {
> > +  ScopedInRtl in_rtl;
> > +  {
> > +    ThreadClock vector1;
> > +    vector1.tick(10);
> > +    ThreadClock vector2;
> > +    vector2.tick(20);
> > +    {
> > +      SyncClock chunked;
> > +      vector1.release(&chunked);
> > +      CHECK_EQ(chunked.size(), 11);
> > +      vector2.release(&chunked);
> > +      CHECK_EQ(chunked.size(), 21);
> > +    }
> > +    {
> > +      SyncClock chunked;
> > +      vector2.release(&chunked);
> > +      CHECK_EQ(chunked.size(), 21);
> > +      vector1.release(&chunked);
> > +      CHECK_EQ(chunked.size(), 21);
> > +    }
> > +    {
> > +      SyncClock chunked;
> > +      vector1.release(&chunked);
> > +      vector2.acquire(&chunked);
> > +      CHECK_EQ(vector2.size(), 21);
> > +    }
> > +    {
> > +      SyncClock chunked;
> > +      vector2.release(&chunked);
> > +      vector1.acquire(&chunked);
> > +      CHECK_EQ(vector1.size(), 21);
> > +    }
> > +  }
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_flags_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_flags_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_flags_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_flags_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,38 @@
> > +//===-- tsan_flags_test.cc
> ------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_flags.h"
> > +#include "tsan_rtl.h"
> > +#include "gtest/gtest.h"
> > +
> > +namespace __tsan {
> > +
> > +TEST(Flags, Basic) {
> > +  ScopedInRtl in_rtl;
> > +  // At least should not crash.
> > +  Flags f = {};
> > +  InitializeFlags(&f, 0);
> > +  InitializeFlags(&f, "");
> > +}
> > +
> > +TEST(Flags, DefaultValues) {
> > +  ScopedInRtl in_rtl;
> > +  Flags f = {};
> > +
> > +  f.enable_annotations = false;
> > +  f.exitcode = -11;
> > +  InitializeFlags(&f, "");
> > +  EXPECT_EQ(66, f.exitcode);
> > +  EXPECT_EQ(true, f.enable_annotations);
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_mman_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_mman_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_mman_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_mman_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,109 @@
> > +//===-- tsan_mman_test.cc
> -------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_mman.h"
> > +#include "tsan_rtl.h"
> > +#include "gtest/gtest.h"
> > +
> > +namespace __tsan {
> > +
> > +TEST(Mman, Internal) {
> > +  ScopedInRtl in_rtl;
> > +  char *p = (char*)internal_alloc(MBlockScopedBuf, 10);
> > +  EXPECT_NE(p, (char*)0);
> > +  char *p2 = (char*)internal_alloc(MBlockScopedBuf, 20);
> > +  EXPECT_NE(p2, (char*)0);
> > +  EXPECT_NE(p2, p);
> > +  for (int i = 0; i < 10; i++) {
> > +    p[i] = 42;
> > +  }
> > +  for (int i = 0; i < 20; i++) {
> > +    ((char*)p2)[i] = 42;
> > +  }
> > +  internal_free(p);
> > +  internal_free(p2);
> > +}
> > +
> > +TEST(Mman, User) {
> > +  ScopedInRtl in_rtl;
> > +  ThreadState *thr = cur_thread();
> > +  uptr pc = 0;
> > +  char *p = (char*)user_alloc(thr, pc, 10);
> > +  EXPECT_NE(p, (char*)0);
> > +  char *p2 = (char*)user_alloc(thr, pc, 20);
> > +  EXPECT_NE(p2, (char*)0);
> > +  EXPECT_NE(p2, p);
> > +  MBlock *b = user_mblock(thr, p);
> > +  EXPECT_NE(b, (MBlock*)0);
> > +  EXPECT_EQ(b->size, (uptr)10);
> > +  MBlock *b2 = user_mblock(thr, p2);
> > +  EXPECT_NE(b2, (MBlock*)0);
> > +  EXPECT_EQ(b2->size, (uptr)20);
> > +  for (int i = 0; i < 10; i++) {
> > +    p[i] = 42;
> > +    EXPECT_EQ(b, user_mblock(thr, p + i));
> > +  }
> > +  for (int i = 0; i < 20; i++) {
> > +    ((char*)p2)[i] = 42;
> > +    EXPECT_EQ(b2, user_mblock(thr, p2 + i));
> > +  }
> > +  user_free(thr, pc, p);
> > +  user_free(thr, pc, p2);
> > +}
> > +
> > +TEST(Mman, UserRealloc) {
> > +  ScopedInRtl in_rtl;
> > +  ThreadState *thr = cur_thread();
> > +  uptr pc = 0;
> > +  {
> > +    void *p = user_realloc(thr, pc, 0, 0);
> > +    // Strictly saying this is incorrect, realloc(NULL, N) is
> equivalent to
> > +    // malloc(N), thus must return non-NULL pointer.
> > +    EXPECT_EQ(p, (void*)0);
> > +  }
> > +  {
> > +    void *p = user_realloc(thr, pc, 0, 100);
> > +    EXPECT_NE(p, (void*)0);
> > +    memset(p, 0xde, 100);
> > +    user_free(thr, pc, p);
> > +  }
> > +  {
> > +    void *p = user_alloc(thr, pc, 100);
> > +    EXPECT_NE(p, (void*)0);
> > +    memset(p, 0xde, 100);
> > +    void *p2 = user_realloc(thr, pc, p, 0);
> > +    EXPECT_EQ(p2, (void*)0);
> > +  }
> > +  {
> > +    void *p = user_realloc(thr, pc, 0, 100);
> > +    EXPECT_NE(p, (void*)0);
> > +    memset(p, 0xde, 100);
> > +    void *p2 = user_realloc(thr, pc, p, 10000);
> > +    EXPECT_NE(p2, (void*)0);
> > +    for (int i = 0; i < 100; i++)
> > +      EXPECT_EQ(((char*)p2)[i], (char)0xde);
> > +    memset(p2, 0xde, 10000);
> > +    user_free(thr, pc, p2);
> > +  }
> > +  {
> > +    void *p = user_realloc(thr, pc, 0, 10000);
> > +    EXPECT_NE(p, (void*)0);
> > +    memset(p, 0xde, 10000);
> > +    void *p2 = user_realloc(thr, pc, p, 10);
> > +    EXPECT_NE(p2, (void*)0);
> > +    for (int i = 0; i < 10; i++)
> > +      EXPECT_EQ(((char*)p2)[i], (char)0xde);
> > +    user_free(thr, pc, p2);
> > +  }
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_mutex_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_mutex_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_mutex_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_mutex_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,126 @@
> > +//===-- tsan_mutex_test.cc
> ------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "sanitizer_common/sanitizer_internal_defs.h"
> > +#include "sanitizer_common/sanitizer_atomic.h"
> > +#include "sanitizer_common/sanitizer_common.h"
> > +#include "sanitizer_common/sanitizer_mutex.h"
> > +#include "tsan_mutex.h"
> > +#include "gtest/gtest.h"
> > +
> > +namespace __tsan {
> > +
> > +template<typename MutexType>
> > +class TestData {
> > + public:
> > +  explicit TestData(MutexType *mtx)
> > +    : mtx_(mtx) {
> > +    for (int i = 0; i < kSize; i++)
> > +      data_[i] = 0;
> > +  }
> > +
> > +  void Write() {
> > +    Lock l(mtx_);
> > +    T v0 = data_[0];
> > +    for (int i = 0; i < kSize; i++) {
> > +      CHECK_EQ(data_[i], v0);
> > +      data_[i]++;
> > +    }
> > +  }
> > +
> > +  void Read() {
> > +    ReadLock l(mtx_);
> > +    T v0 = data_[0];
> > +    for (int i = 0; i < kSize; i++) {
> > +      CHECK_EQ(data_[i], v0);
> > +    }
> > +  }
> > +
> > +  void Backoff() {
> > +    volatile T data[kSize] = {};
> > +    for (int i = 0; i < kSize; i++) {
> > +      data[i]++;
> > +      CHECK_EQ(data[i], 1);
> > +    }
> > +  }
> > +
> > + private:
> > +  typedef GenericScopedLock<MutexType> Lock;
> > +  static const int kSize = 64;
> > +  typedef u64 T;
> > +  MutexType *mtx_;
> > +  char pad_[kCacheLineSize];
> > +  T data_[kSize];
> > +};
> > +
> > +const int kThreads = 8;
> > +const int kWriteRate = 1024;
> > +#if TSAN_DEBUG
> > +const int kIters = 16*1024;
> > +#else
> > +const int kIters = 64*1024;
> > +#endif
> > +
> > +template<typename MutexType>
> > +static void *write_mutex_thread(void *param) {
> > +  TestData<MutexType> *data = (TestData<MutexType>*)param;
> > +  for (int i = 0; i < kIters; i++) {
> > +    data->Write();
> > +    data->Backoff();
> > +  }
> > +  return 0;
> > +}
> > +
> > +template<typename MutexType>
> > +static void *read_mutex_thread(void *param) {
> > +  TestData<MutexType> *data = (TestData<MutexType>*)param;
> > +  for (int i = 0; i < kIters; i++) {
> > +    if ((i % kWriteRate) == 0)
> > +      data->Write();
> > +    else
> > +      data->Read();
> > +    data->Backoff();
> > +  }
> > +  return 0;
> > +}
> > +
> > +TEST(Mutex, Write) {
> > +  Mutex mtx(MutexTypeAnnotations, StatMtxAnnotations);
> > +  TestData<Mutex> data(&mtx);
> > +  pthread_t threads[kThreads];
> > +  for (int i = 0; i < kThreads; i++)
> > +    pthread_create(&threads[i], 0, write_mutex_thread<Mutex>, &data);
> > +  for (int i = 0; i < kThreads; i++)
> > +    pthread_join(threads[i], 0);
> > +}
> > +
> > +TEST(Mutex, ReadWrite) {
> > +  Mutex mtx(MutexTypeAnnotations, StatMtxAnnotations);
> > +  TestData<Mutex> data(&mtx);
> > +  pthread_t threads[kThreads];
> > +  for (int i = 0; i < kThreads; i++)
> > +    pthread_create(&threads[i], 0, read_mutex_thread<Mutex>, &data);
> > +  for (int i = 0; i < kThreads; i++)
> > +    pthread_join(threads[i], 0);
> > +}
> > +
> > +TEST(Mutex, SpinWrite) {
> > +  SpinMutex mtx;
> > +  TestData<SpinMutex> data(&mtx);
> > +  pthread_t threads[kThreads];
> > +  for (int i = 0; i < kThreads; i++)
> > +    pthread_create(&threads[i], 0, write_mutex_thread<SpinMutex>,
> &data);
> > +  for (int i = 0; i < kThreads; i++)
> > +    pthread_join(threads[i], 0);
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_platform_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_platform_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_platform_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_platform_test.cc Mon Sep
> 17 05:02:17 2012
> > @@ -0,0 +1,88 @@
> > +//===-- tsan_platform_test.cc
> ---------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "sanitizer_common/sanitizer_libc.h"
> > +#include "tsan_platform.h"
> > +#include "gtest/gtest.h"
> > +
> > +namespace __tsan {
> > +
> > +static void TestThreadInfo(bool main) {
> > +  ScopedInRtl in_rtl;
> > +  uptr stk_addr = 0;
> > +  uptr stk_size = 0;
> > +  uptr tls_addr = 0;
> > +  uptr tls_size = 0;
> > +  GetThreadStackAndTls(main, &stk_addr, &stk_size, &tls_addr,
> &tls_size);
> > +  // Printf("stk=%zx-%zx(%zu)\n", stk_addr, stk_addr + stk_size,
> stk_size);
> > +  // Printf("tls=%zx-%zx(%zu)\n", tls_addr, tls_addr + tls_size,
> tls_size);
> > +
> > +  int stack_var;
> > +  EXPECT_NE(stk_addr, (uptr)0);
> > +  EXPECT_NE(stk_size, (uptr)0);
> > +  EXPECT_GT((uptr)&stack_var, stk_addr);
> > +  EXPECT_LT((uptr)&stack_var, stk_addr + stk_size);
> > +
> > +  static __thread int thread_var;
> > +  EXPECT_NE(tls_addr, (uptr)0);
> > +  EXPECT_NE(tls_size, (uptr)0);
> > +  EXPECT_GT((uptr)&thread_var, tls_addr);
> > +  EXPECT_LT((uptr)&thread_var, tls_addr + tls_size);
> > +
> > +  // Ensure that tls and stack do not intersect.
> > +  uptr tls_end = tls_addr + tls_size;
> > +  EXPECT_TRUE(tls_addr < stk_addr || tls_addr >= stk_addr + stk_size);
> > +  EXPECT_TRUE(tls_end  < stk_addr || tls_end  >=  stk_addr + stk_size);
> > +  EXPECT_TRUE((tls_addr < stk_addr) == (tls_end  < stk_addr));
> > +}
> > +
> > +static void *WorkerThread(void *arg) {
> > +  TestThreadInfo(false);
> > +  return 0;
> > +}
> > +
> > +TEST(Platform, ThreadInfoMain) {
> > +  TestThreadInfo(true);
> > +}
> > +
> > +TEST(Platform, ThreadInfoWorker) {
> > +  pthread_t t;
> > +  pthread_create(&t, 0, WorkerThread, 0);
> > +  pthread_join(t, 0);
> > +}
> > +
> > +TEST(Platform, FileOps) {
> > +  const char *str1 = "qwerty";
> > +  uptr len1 = internal_strlen(str1);
> > +  const char *str2 = "zxcv";
> > +  uptr len2 = internal_strlen(str2);
> > +
> > +  fd_t fd = internal_open("./tsan_test.tmp", true);
> > +  EXPECT_NE(fd, kInvalidFd);
> > +  EXPECT_EQ(len1, internal_write(fd, str1, len1));
> > +  EXPECT_EQ(len2, internal_write(fd, str2, len2));
> > +  internal_close(fd);
> > +
> > +  fd = internal_open("./tsan_test.tmp", false);
> > +  EXPECT_NE(fd, kInvalidFd);
> > +  EXPECT_EQ(len1 + len2, internal_filesize(fd));
> > +  char buf[64] = {};
> > +  EXPECT_EQ(len1, internal_read(fd, buf, len1));
> > +  EXPECT_EQ(0, internal_memcmp(buf, str1, len1));
> > +  EXPECT_EQ((char)0, buf[len1 + 1]);
> > +  internal_memset(buf, 0, len1);
> > +  EXPECT_EQ(len2, internal_read(fd, buf, len2));
> > +  EXPECT_EQ(0, internal_memcmp(buf, str2, len2));
> > +  internal_close(fd);
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_printf_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_printf_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_printf_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_printf_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,106 @@
> > +//===-- tsan_printf_test.cc
> -----------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_rtl.h"
> > +#include "gtest/gtest.h"
> > +
> > +#include <string.h>
> > +#include <limits.h>
> > +
> > +namespace __tsan {
> > +
> > +TEST(Printf, Basic) {
> > +  char buf[1024];
> > +  uptr len = internal_snprintf(buf, sizeof(buf),
> > +      "a%db%zdc%ue%zuf%xh%zxq%pe%sr",
> > +      (int)-1, (long)-2, // NOLINT
> > +      (unsigned)-4, (unsigned long)5, // NOLINT
> > +      (unsigned)10, (unsigned long)11, // NOLINT
> > +      (void*)0x123, "_string_");
> > +  EXPECT_EQ(len, strlen(buf));
> > +  EXPECT_EQ(0, strcmp(buf, "a-1b-2c4294967292e5fahbq"
> > +                           "0x000000000123e_string_r"));
> > +}
> > +
> > +TEST(Printf, OverflowStr) {
> > +  char buf[] = "123456789";
> > +  uptr len = internal_snprintf(buf, 4, "%s", "abcdef");  // NOLINT
> > +  EXPECT_EQ(len, (uptr)6);
> > +  EXPECT_EQ(0, strcmp(buf, "abc"));
> > +  EXPECT_EQ(buf[3], 0);
> > +  EXPECT_EQ(buf[4], '5');
> > +  EXPECT_EQ(buf[5], '6');
> > +  EXPECT_EQ(buf[6], '7');
> > +  EXPECT_EQ(buf[7], '8');
> > +  EXPECT_EQ(buf[8], '9');
> > +  EXPECT_EQ(buf[9], 0);
> > +}
> > +
> > +TEST(Printf, OverflowInt) {
> > +  char buf[] = "123456789";
> > +  internal_snprintf(buf, 4, "%d", -123456789);  // NOLINT
> > +  EXPECT_EQ(0, strcmp(buf, "-12"));
> > +  EXPECT_EQ(buf[3], 0);
> > +  EXPECT_EQ(buf[4], '5');
> > +  EXPECT_EQ(buf[5], '6');
> > +  EXPECT_EQ(buf[6], '7');
> > +  EXPECT_EQ(buf[7], '8');
> > +  EXPECT_EQ(buf[8], '9');
> > +  EXPECT_EQ(buf[9], 0);
> > +}
> > +
> > +TEST(Printf, OverflowUint) {
> > +  char buf[] = "123456789";
> > +  internal_snprintf(buf, 4, "a%zx", (unsigned long)0x123456789);  //
> NOLINT
> > +  EXPECT_EQ(0, strcmp(buf, "a12"));
> > +  EXPECT_EQ(buf[3], 0);
> > +  EXPECT_EQ(buf[4], '5');
> > +  EXPECT_EQ(buf[5], '6');
> > +  EXPECT_EQ(buf[6], '7');
> > +  EXPECT_EQ(buf[7], '8');
> > +  EXPECT_EQ(buf[8], '9');
> > +  EXPECT_EQ(buf[9], 0);
> > +}
> > +
> > +TEST(Printf, OverflowPtr) {
> > +  char buf[] = "123456789";
> > +  internal_snprintf(buf, 4, "%p", (void*)0x123456789);  // NOLINT
> > +  EXPECT_EQ(0, strcmp(buf, "0x0"));
> > +  EXPECT_EQ(buf[3], 0);
> > +  EXPECT_EQ(buf[4], '5');
> > +  EXPECT_EQ(buf[5], '6');
> > +  EXPECT_EQ(buf[6], '7');
> > +  EXPECT_EQ(buf[7], '8');
> > +  EXPECT_EQ(buf[8], '9');
> > +  EXPECT_EQ(buf[9], 0);
> > +}
> > +
> > +template<typename T>
> > +static void TestMinMax(const char *fmt, T min, T max) {
> > +  char buf[1024];
> > +  uptr len = internal_snprintf(buf, sizeof(buf), fmt, min, max);
> > +  char buf2[1024];
> > +  snprintf(buf2, sizeof(buf2), fmt, min, max);
> > +  EXPECT_EQ(len, strlen(buf));
> > +  EXPECT_EQ(0, strcmp(buf, buf2));
> > +}
> > +
> > +TEST(Printf, MinMax) {
> > +  TestMinMax<int>("%d-%d", INT_MIN, INT_MAX);  // NOLINT
> > +  TestMinMax<long>("%zd-%zd", LONG_MIN, LONG_MAX);  // NOLINT
> > +  TestMinMax<unsigned>("%u-%u", 0, UINT_MAX);  // NOLINT
> > +  TestMinMax<unsigned long>("%zu-%zu", 0, ULONG_MAX);  // NOLINT
> > +  TestMinMax<unsigned>("%x-%x", 0, UINT_MAX);  // NOLINT
> > +  TestMinMax<unsigned long>("%zx-%zx", 0, ULONG_MAX);  // NOLINT
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_shadow_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_shadow_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_shadow_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_shadow_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,47 @@
> > +//===-- tsan_shadow_test.cc
> -----------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_platform.h"
> > +#include "gtest/gtest.h"
> > +
> > +namespace __tsan {
> > +
> > +TEST(Shadow, Mapping) {
> > +  static int global;
> > +  int stack;
> > +  void *heap = malloc(0);
> > +  free(heap);
> > +
> > +  CHECK(IsAppMem((uptr)&global));
> > +  CHECK(IsAppMem((uptr)&stack));
> > +  CHECK(IsAppMem((uptr)heap));
> > +
> > +  CHECK(IsShadowMem(MemToShadow((uptr)&global)));
> > +  CHECK(IsShadowMem(MemToShadow((uptr)&stack)));
> > +  CHECK(IsShadowMem(MemToShadow((uptr)heap)));
> > +}
> > +
> > +TEST(Shadow, Celling) {
> > +  u64 aligned_data[4];
> > +  char *data = (char*)aligned_data;
> > +  CHECK_EQ((uptr)data % kShadowSize, 0);
> > +  uptr s0 = MemToShadow((uptr)&data[0]);
> > +  CHECK_EQ(s0 % kShadowSize, 0);
> > +  for (unsigned i = 1; i < kShadowCell; i++)
> > +    CHECK_EQ(s0, MemToShadow((uptr)&data[i]));
> > +  for (unsigned i = kShadowCell; i < 2*kShadowCell; i++)
> > +    CHECK_EQ(s0 + kShadowSize*kShadowCnt, MemToShadow((uptr)&data[i]));
> > +  for (unsigned i = 2*kShadowCell; i < 3*kShadowCell; i++)
> > +    CHECK_EQ(s0 + 2*kShadowSize*kShadowCnt,
> MemToShadow((uptr)&data[i]));
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_stack_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_stack_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_stack_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_stack_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,80 @@
> > +//===-- tsan_stack_test.cc
> ------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_sync.h"
> > +#include "tsan_rtl.h"
> > +#include "gtest/gtest.h"
> > +#include <string.h>
> > +
> > +namespace __tsan {
> > +
> > +static void TestStackTrace(StackTrace *trace) {
> > +  ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0);
> > +
> > +  trace->ObtainCurrent(&thr, 0);
> > +  EXPECT_EQ(trace->Size(), (uptr)0);
> > +
> > +  trace->ObtainCurrent(&thr, 42);
> > +  EXPECT_EQ(trace->Size(), (uptr)1);
> > +  EXPECT_EQ(trace->Get(0), (uptr)42);
> > +
> > +  *thr.shadow_stack_pos++ = 100;
> > +  *thr.shadow_stack_pos++ = 101;
> > +  trace->ObtainCurrent(&thr, 0);
> > +  EXPECT_EQ(trace->Size(), (uptr)2);
> > +  EXPECT_EQ(trace->Get(0), (uptr)100);
> > +  EXPECT_EQ(trace->Get(1), (uptr)101);
> > +
> > +  trace->ObtainCurrent(&thr, 42);
> > +  EXPECT_EQ(trace->Size(), (uptr)3);
> > +  EXPECT_EQ(trace->Get(0), (uptr)100);
> > +  EXPECT_EQ(trace->Get(1), (uptr)101);
> > +  EXPECT_EQ(trace->Get(2), (uptr)42);
> > +}
> > +
> > +TEST(StackTrace, Basic) {
> > +  ScopedInRtl in_rtl;
> > +  StackTrace trace;
> > +  TestStackTrace(&trace);
> > +}
> > +
> > +TEST(StackTrace, StaticBasic) {
> > +  ScopedInRtl in_rtl;
> > +  uptr buf[10];
> > +  StackTrace trace1(buf, 10);
> > +  TestStackTrace(&trace1);
> > +  StackTrace trace2(buf, 3);
> > +  TestStackTrace(&trace2);
> > +}
> > +
> > +TEST(StackTrace, StaticTrim) {
> > +  ScopedInRtl in_rtl;
> > +  uptr buf[2];
> > +  StackTrace trace(buf, 2);
> > +  ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0);
> > +
> > +  *thr.shadow_stack_pos++ = 100;
> > +  *thr.shadow_stack_pos++ = 101;
> > +  *thr.shadow_stack_pos++ = 102;
> > +  trace.ObtainCurrent(&thr, 0);
> > +  EXPECT_EQ(trace.Size(), (uptr)2);
> > +  EXPECT_EQ(trace.Get(0), (uptr)101);
> > +  EXPECT_EQ(trace.Get(1), (uptr)102);
> > +
> > +  trace.ObtainCurrent(&thr, 42);
> > +  EXPECT_EQ(trace.Size(), (uptr)2);
> > +  EXPECT_EQ(trace.Get(0), (uptr)102);
> > +  EXPECT_EQ(trace.Get(1), (uptr)42);
> > +}
> > +
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_suppressions_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_suppressions_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_suppressions_test.cc
> (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_suppressions_test.cc Mon
> Sep 17 05:02:17 2012
> > @@ -0,0 +1,128 @@
> > +//===-- tsan_suppressions_test.cc
> -----------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_suppressions.h"
> > +#include "tsan_rtl.h"
> > +#include "gtest/gtest.h"
> > +
> > +#include <string.h>
> > +
> > +namespace __tsan {
> > +
> > +TEST(Suppressions, Parse) {
> > +  ScopedInRtl in_rtl;
> > +  Suppression *supp0 = SuppressionParse(
> > +    "race:foo\n"
> > +    "  race:bar\n"  // NOLINT
> > +    "race:baz   \n"  // NOLINT
> > +    "# a comment\n"
> > +    "race:quz\n"
> > +  );  // NOLINT
> > +  Suppression *supp = supp0;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "quz"));
> > +  supp = supp->next;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "baz"));
> > +  supp = supp->next;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "bar"));
> > +  supp = supp->next;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "foo"));
> > +  supp = supp->next;
> > +  EXPECT_EQ((Suppression*)0, supp);
> > +}
> > +
> > +TEST(Suppressions, Parse2) {
> > +  ScopedInRtl in_rtl;
> > +  Suppression *supp0 = SuppressionParse(
> > +    "          # first line comment\n"  // NOLINT
> > +    "  race:bar        \n"  // NOLINT
> > +    "race:baz* *baz\n"
> > +    "# a comment\n"
> > +    "# last line comment\n"
> > +  );  // NOLINT
> > +  Suppression *supp = supp0;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "baz* *baz"));
> > +  supp = supp->next;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "bar"));
> > +  supp = supp->next;
> > +  EXPECT_EQ((Suppression*)0, supp);
> > +}
> > +
> > +TEST(Suppressions, Parse3) {
> > +  ScopedInRtl in_rtl;
> > +  Suppression *supp0 = SuppressionParse(
> > +    "# last suppression w/o line-feed\n"
> > +    "race:foo\n"
> > +    "race:bar"
> > +  );  // NOLINT
> > +  Suppression *supp = supp0;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "bar"));
> > +  supp = supp->next;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "foo"));
> > +  supp = supp->next;
> > +  EXPECT_EQ((Suppression*)0, supp);
> > +}
> > +
> > +TEST(Suppressions, ParseType) {
> > +  ScopedInRtl in_rtl;
> > +  Suppression *supp0 = SuppressionParse(
> > +    "race:foo\n"
> > +    "thread:bar\n"
> > +    "mutex:baz\n"
> > +    "signal:quz\n"
> > +  );  // NOLINT
> > +  Suppression *supp = supp0;
> > +  EXPECT_EQ(supp->type, SuppressionSignal);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "quz"));
> > +  supp = supp->next;
> > +  EXPECT_EQ(supp->type, SuppressionMutex);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "baz"));
> > +  supp = supp->next;
> > +  EXPECT_EQ(supp->type, SuppressionThread);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "bar"));
> > +  supp = supp->next;
> > +  EXPECT_EQ(supp->type, SuppressionRace);
> > +  EXPECT_EQ(0, strcmp(supp->templ, "foo"));
> > +  supp = supp->next;
> > +  EXPECT_EQ((Suppression*)0, supp);
> > +}
> > +
> > +static bool MyMatch(const char *templ, const char *func) {
> > +  char tmp[1024];
> > +  strcpy(tmp, templ);  // NOLINT
> > +  return SuppressionMatch(tmp, func);
> > +}
> > +
> > +TEST(Suppressions, Match) {
> > +  EXPECT_TRUE(MyMatch("foobar", "foobar"));
> > +  EXPECT_TRUE(MyMatch("foobar", "prefix_foobar_postfix"));
> > +  EXPECT_TRUE(MyMatch("*foobar*", "prefix_foobar_postfix"));
> > +  EXPECT_TRUE(MyMatch("foo*bar", "foo_middle_bar"));
> > +  EXPECT_TRUE(MyMatch("foo*bar", "foobar"));
> > +  EXPECT_TRUE(MyMatch("foo*bar*baz", "foo_middle_bar_another_baz"));
> > +  EXPECT_TRUE(MyMatch("foo*bar*baz", "foo_middle_barbaz"));
> > +
> > +  EXPECT_FALSE(MyMatch("foo", "baz"));
> > +  EXPECT_FALSE(MyMatch("foobarbaz", "foobar"));
> > +  EXPECT_FALSE(MyMatch("foobarbaz", "barbaz"));
> > +  EXPECT_FALSE(MyMatch("foo*bar", "foobaz"));
> > +  EXPECT_FALSE(MyMatch("foo*bar", "foo_baz"));
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_sync_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_sync_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_sync_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_sync_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,65 @@
> > +//===-- tsan_sync_test.cc
> -------------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_sync.h"
> > +#include "tsan_rtl.h"
> > +#include "tsan_mman.h"
> > +#include "gtest/gtest.h"
> > +
> > +#include <stdlib.h>
> > +#include <stdint.h>
> > +#include <map>
> > +
> > +namespace __tsan {
> > +
> > +TEST(Sync, Table) {
> > +  const uintptr_t kIters = 512*1024;
> > +  const uintptr_t kRange = 10000;
> > +
> > +  ScopedInRtl in_rtl;
> > +  ThreadState *thr = cur_thread();
> > +  uptr pc = 0;
> > +
> > +  SyncTab tab;
> > +  SyncVar *golden[kRange] = {};
> > +  unsigned seed = 0;
> > +  for (uintptr_t i = 0; i < kIters; i++) {
> > +    uintptr_t addr = rand_r(&seed) % (kRange - 1) + 1;
> > +    if (rand_r(&seed) % 2) {
> > +      // Get or add.
> > +      SyncVar *v = tab.GetAndLock(thr, pc, addr, true);
> > +      EXPECT_TRUE(golden[addr] == 0 || golden[addr] == v);
> > +      EXPECT_EQ(v->addr, addr);
> > +      golden[addr] = v;
> > +      v->mtx.Unlock();
> > +    } else {
> > +      // Remove.
> > +      SyncVar *v = tab.GetAndRemove(thr, pc, addr);
> > +      EXPECT_EQ(golden[addr], v);
> > +      if (v) {
> > +        EXPECT_EQ(v->addr, addr);
> > +        golden[addr] = 0;
> > +        DestroyAndFree(v);
> > +      }
> > +    }
> > +  }
> > +  for (uintptr_t addr = 0; addr < kRange; addr++) {
> > +    if (golden[addr] == 0)
> > +      continue;
> > +    SyncVar *v = tab.GetAndRemove(thr, pc, addr);
> > +    EXPECT_EQ(v, golden[addr]);
> > +    EXPECT_EQ(v->addr, addr);
> > +    DestroyAndFree(v);
> > +  }
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Added: compiler-rt/trunk/lib/tsan/tests/unit/tsan_vector_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/tests/unit/tsan_vector_test.cc?rev=164022&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/tests/unit/tsan_vector_test.cc (added)
> > +++ compiler-rt/trunk/lib/tsan/tests/unit/tsan_vector_test.cc Mon Sep 17
> 05:02:17 2012
> > @@ -0,0 +1,45 @@
> > +//===-- tsan_vector_test.cc
> -----------------------------------------------===//
> > +//
> > +//                     The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open Source
> > +// License. See LICENSE.TXT for details.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +//
> > +// This file is a part of ThreadSanitizer (TSan), a race detector.
> > +//
> >
> +//===----------------------------------------------------------------------===//
> > +#include "tsan_vector.h"
> > +#include "tsan_rtl.h"
> > +#include "gtest/gtest.h"
> > +
> > +namespace __tsan {
> > +
> > +TEST(Vector, Basic) {
> > +  ScopedInRtl in_rtl;
> > +  Vector<int> v(MBlockScopedBuf);
> > +  EXPECT_EQ(v.Size(), (uptr)0);
> > +  v.PushBack(42);
> > +  EXPECT_EQ(v.Size(), (uptr)1);
> > +  EXPECT_EQ(v[0], 42);
> > +  v.PushBack(43);
> > +  EXPECT_EQ(v.Size(), (uptr)2);
> > +  EXPECT_EQ(v[0], 42);
> > +  EXPECT_EQ(v[1], 43);
> > +}
> > +
> > +TEST(Vector, Stride) {
> > +  ScopedInRtl in_rtl;
> > +  Vector<int> v(MBlockScopedBuf);
> > +  for (int i = 0; i < 1000; i++) {
> > +    v.PushBack(i);
> > +    EXPECT_EQ(v.Size(), (uptr)(i + 1));
> > +    EXPECT_EQ(v[i], i);
> > +  }
> > +  for (int i = 0; i < 1000; i++) {
> > +    EXPECT_EQ(v[i], i);
> > +  }
> > +}
> > +
> > +}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/CMakeLists.txt?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/CMakeLists.txt (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/CMakeLists.txt (removed)
> > @@ -1,15 +0,0 @@
> > -set(TSAN_UNIT_TESTS
> > -  tsan_clock_test.cc
> > -  tsan_flags_test.cc
> > -  tsan_mman_test.cc
> > -  tsan_mutex_test.cc
> > -  tsan_platform_test.cc
> > -  tsan_printf_test.cc
> > -  tsan_shadow_test.cc
> > -  tsan_stack_test.cc
> > -  tsan_suppressions_test.cc
> > -  tsan_sync_test.cc
> > -  tsan_vector_test.cc
> > -  )
> > -
> > -add_tsan_unittest(TsanUnitTest ${TSAN_UNIT_TESTS})
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_clock_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_clock_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_clock_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_clock_test.cc (removed)
> > @@ -1,123 +0,0 @@
> > -//===-- tsan_clock_test.cc
> ------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_clock.h"
> > -#include "tsan_rtl.h"
> > -#include "gtest/gtest.h"
> > -
> > -namespace __tsan {
> > -
> > -TEST(Clock, VectorBasic) {
> > -  ScopedInRtl in_rtl;
> > -  ThreadClock clk;
> > -  CHECK_EQ(clk.size(), 0);
> > -  clk.tick(0);
> > -  CHECK_EQ(clk.size(), 1);
> > -  CHECK_EQ(clk.get(0), 1);
> > -  clk.tick(3);
> > -  CHECK_EQ(clk.size(), 4);
> > -  CHECK_EQ(clk.get(0), 1);
> > -  CHECK_EQ(clk.get(1), 0);
> > -  CHECK_EQ(clk.get(2), 0);
> > -  CHECK_EQ(clk.get(3), 1);
> > -  clk.tick(3);
> > -  CHECK_EQ(clk.get(3), 2);
> > -}
> > -
> > -TEST(Clock, ChunkedBasic) {
> > -  ScopedInRtl in_rtl;
> > -  ThreadClock vector;
> > -  SyncClock chunked;
> > -  CHECK_EQ(vector.size(), 0);
> > -  CHECK_EQ(chunked.size(), 0);
> > -  vector.acquire(&chunked);
> > -  CHECK_EQ(vector.size(), 0);
> > -  CHECK_EQ(chunked.size(), 0);
> > -  vector.release(&chunked);
> > -  CHECK_EQ(vector.size(), 0);
> > -  CHECK_EQ(chunked.size(), 0);
> > -  vector.acq_rel(&chunked);
> > -  CHECK_EQ(vector.size(), 0);
> > -  CHECK_EQ(chunked.size(), 0);
> > -}
> > -
> > -TEST(Clock, AcquireRelease) {
> > -  ScopedInRtl in_rtl;
> > -  ThreadClock vector1;
> > -  vector1.tick(100);
> > -  SyncClock chunked;
> > -  vector1.release(&chunked);
> > -  CHECK_EQ(chunked.size(), 101);
> > -  ThreadClock vector2;
> > -  vector2.acquire(&chunked);
> > -  CHECK_EQ(vector2.size(), 101);
> > -  CHECK_EQ(vector2.get(0), 0);
> > -  CHECK_EQ(vector2.get(1), 0);
> > -  CHECK_EQ(vector2.get(99), 0);
> > -  CHECK_EQ(vector2.get(100), 1);
> > -}
> > -
> > -TEST(Clock, ManyThreads) {
> > -  ScopedInRtl in_rtl;
> > -  SyncClock chunked;
> > -  for (int i = 0; i < 100; i++) {
> > -    ThreadClock vector;
> > -    vector.tick(i);
> > -    vector.release(&chunked);
> > -    CHECK_EQ(chunked.size(), i + 1);
> > -    vector.acquire(&chunked);
> > -    CHECK_EQ(vector.size(), i + 1);
> > -  }
> > -  ThreadClock vector;
> > -  vector.acquire(&chunked);
> > -  CHECK_EQ(vector.size(), 100);
> > -  for (int i = 0; i < 100; i++)
> > -    CHECK_EQ(vector.get(i), 1);
> > -}
> > -
> > -TEST(Clock, DifferentSizes) {
> > -  ScopedInRtl in_rtl;
> > -  {
> > -    ThreadClock vector1;
> > -    vector1.tick(10);
> > -    ThreadClock vector2;
> > -    vector2.tick(20);
> > -    {
> > -      SyncClock chunked;
> > -      vector1.release(&chunked);
> > -      CHECK_EQ(chunked.size(), 11);
> > -      vector2.release(&chunked);
> > -      CHECK_EQ(chunked.size(), 21);
> > -    }
> > -    {
> > -      SyncClock chunked;
> > -      vector2.release(&chunked);
> > -      CHECK_EQ(chunked.size(), 21);
> > -      vector1.release(&chunked);
> > -      CHECK_EQ(chunked.size(), 21);
> > -    }
> > -    {
> > -      SyncClock chunked;
> > -      vector1.release(&chunked);
> > -      vector2.acquire(&chunked);
> > -      CHECK_EQ(vector2.size(), 21);
> > -    }
> > -    {
> > -      SyncClock chunked;
> > -      vector2.release(&chunked);
> > -      vector1.acquire(&chunked);
> > -      CHECK_EQ(vector1.size(), 21);
> > -    }
> > -  }
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_flags_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_flags_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_flags_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_flags_test.cc (removed)
> > @@ -1,38 +0,0 @@
> > -//===-- tsan_flags_test.cc
> ------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_flags.h"
> > -#include "tsan_rtl.h"
> > -#include "gtest/gtest.h"
> > -
> > -namespace __tsan {
> > -
> > -TEST(Flags, Basic) {
> > -  ScopedInRtl in_rtl;
> > -  // At least should not crash.
> > -  Flags f = {};
> > -  InitializeFlags(&f, 0);
> > -  InitializeFlags(&f, "");
> > -}
> > -
> > -TEST(Flags, DefaultValues) {
> > -  ScopedInRtl in_rtl;
> > -  Flags f = {};
> > -
> > -  f.enable_annotations = false;
> > -  f.exitcode = -11;
> > -  InitializeFlags(&f, "");
> > -  EXPECT_EQ(66, f.exitcode);
> > -  EXPECT_EQ(true, f.enable_annotations);
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_mman_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_mman_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_mman_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_mman_test.cc (removed)
> > @@ -1,109 +0,0 @@
> > -//===-- tsan_mman_test.cc
> -------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_mman.h"
> > -#include "tsan_rtl.h"
> > -#include "gtest/gtest.h"
> > -
> > -namespace __tsan {
> > -
> > -TEST(Mman, Internal) {
> > -  ScopedInRtl in_rtl;
> > -  char *p = (char*)internal_alloc(MBlockScopedBuf, 10);
> > -  EXPECT_NE(p, (char*)0);
> > -  char *p2 = (char*)internal_alloc(MBlockScopedBuf, 20);
> > -  EXPECT_NE(p2, (char*)0);
> > -  EXPECT_NE(p2, p);
> > -  for (int i = 0; i < 10; i++) {
> > -    p[i] = 42;
> > -  }
> > -  for (int i = 0; i < 20; i++) {
> > -    ((char*)p2)[i] = 42;
> > -  }
> > -  internal_free(p);
> > -  internal_free(p2);
> > -}
> > -
> > -TEST(Mman, User) {
> > -  ScopedInRtl in_rtl;
> > -  ThreadState *thr = cur_thread();
> > -  uptr pc = 0;
> > -  char *p = (char*)user_alloc(thr, pc, 10);
> > -  EXPECT_NE(p, (char*)0);
> > -  char *p2 = (char*)user_alloc(thr, pc, 20);
> > -  EXPECT_NE(p2, (char*)0);
> > -  EXPECT_NE(p2, p);
> > -  MBlock *b = user_mblock(thr, p);
> > -  EXPECT_NE(b, (MBlock*)0);
> > -  EXPECT_EQ(b->size, (uptr)10);
> > -  MBlock *b2 = user_mblock(thr, p2);
> > -  EXPECT_NE(b2, (MBlock*)0);
> > -  EXPECT_EQ(b2->size, (uptr)20);
> > -  for (int i = 0; i < 10; i++) {
> > -    p[i] = 42;
> > -    EXPECT_EQ(b, user_mblock(thr, p + i));
> > -  }
> > -  for (int i = 0; i < 20; i++) {
> > -    ((char*)p2)[i] = 42;
> > -    EXPECT_EQ(b2, user_mblock(thr, p2 + i));
> > -  }
> > -  user_free(thr, pc, p);
> > -  user_free(thr, pc, p2);
> > -}
> > -
> > -TEST(Mman, UserRealloc) {
> > -  ScopedInRtl in_rtl;
> > -  ThreadState *thr = cur_thread();
> > -  uptr pc = 0;
> > -  {
> > -    void *p = user_realloc(thr, pc, 0, 0);
> > -    // Strictly saying this is incorrect, realloc(NULL, N) is
> equivalent to
> > -    // malloc(N), thus must return non-NULL pointer.
> > -    EXPECT_EQ(p, (void*)0);
> > -  }
> > -  {
> > -    void *p = user_realloc(thr, pc, 0, 100);
> > -    EXPECT_NE(p, (void*)0);
> > -    memset(p, 0xde, 100);
> > -    user_free(thr, pc, p);
> > -  }
> > -  {
> > -    void *p = user_alloc(thr, pc, 100);
> > -    EXPECT_NE(p, (void*)0);
> > -    memset(p, 0xde, 100);
> > -    void *p2 = user_realloc(thr, pc, p, 0);
> > -    EXPECT_EQ(p2, (void*)0);
> > -  }
> > -  {
> > -    void *p = user_realloc(thr, pc, 0, 100);
> > -    EXPECT_NE(p, (void*)0);
> > -    memset(p, 0xde, 100);
> > -    void *p2 = user_realloc(thr, pc, p, 10000);
> > -    EXPECT_NE(p2, (void*)0);
> > -    for (int i = 0; i < 100; i++)
> > -      EXPECT_EQ(((char*)p2)[i], (char)0xde);
> > -    memset(p2, 0xde, 10000);
> > -    user_free(thr, pc, p2);
> > -  }
> > -  {
> > -    void *p = user_realloc(thr, pc, 0, 10000);
> > -    EXPECT_NE(p, (void*)0);
> > -    memset(p, 0xde, 10000);
> > -    void *p2 = user_realloc(thr, pc, p, 10);
> > -    EXPECT_NE(p2, (void*)0);
> > -    for (int i = 0; i < 10; i++)
> > -      EXPECT_EQ(((char*)p2)[i], (char)0xde);
> > -    user_free(thr, pc, p2);
> > -  }
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_mutex_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_mutex_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_mutex_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_mutex_test.cc (removed)
> > @@ -1,126 +0,0 @@
> > -//===-- tsan_mutex_test.cc
> ------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "sanitizer_common/sanitizer_internal_defs.h"
> > -#include "sanitizer_common/sanitizer_atomic.h"
> > -#include "sanitizer_common/sanitizer_common.h"
> > -#include "sanitizer_common/sanitizer_mutex.h"
> > -#include "tsan_mutex.h"
> > -#include "gtest/gtest.h"
> > -
> > -namespace __tsan {
> > -
> > -template<typename MutexType>
> > -class TestData {
> > - public:
> > -  explicit TestData(MutexType *mtx)
> > -    : mtx_(mtx) {
> > -    for (int i = 0; i < kSize; i++)
> > -      data_[i] = 0;
> > -  }
> > -
> > -  void Write() {
> > -    Lock l(mtx_);
> > -    T v0 = data_[0];
> > -    for (int i = 0; i < kSize; i++) {
> > -      CHECK_EQ(data_[i], v0);
> > -      data_[i]++;
> > -    }
> > -  }
> > -
> > -  void Read() {
> > -    ReadLock l(mtx_);
> > -    T v0 = data_[0];
> > -    for (int i = 0; i < kSize; i++) {
> > -      CHECK_EQ(data_[i], v0);
> > -    }
> > -  }
> > -
> > -  void Backoff() {
> > -    volatile T data[kSize] = {};
> > -    for (int i = 0; i < kSize; i++) {
> > -      data[i]++;
> > -      CHECK_EQ(data[i], 1);
> > -    }
> > -  }
> > -
> > - private:
> > -  typedef GenericScopedLock<MutexType> Lock;
> > -  static const int kSize = 64;
> > -  typedef u64 T;
> > -  MutexType *mtx_;
> > -  char pad_[kCacheLineSize];
> > -  T data_[kSize];
> > -};
> > -
> > -const int kThreads = 8;
> > -const int kWriteRate = 1024;
> > -#if TSAN_DEBUG
> > -const int kIters = 16*1024;
> > -#else
> > -const int kIters = 64*1024;
> > -#endif
> > -
> > -template<typename MutexType>
> > -static void *write_mutex_thread(void *param) {
> > -  TestData<MutexType> *data = (TestData<MutexType>*)param;
> > -  for (int i = 0; i < kIters; i++) {
> > -    data->Write();
> > -    data->Backoff();
> > -  }
> > -  return 0;
> > -}
> > -
> > -template<typename MutexType>
> > -static void *read_mutex_thread(void *param) {
> > -  TestData<MutexType> *data = (TestData<MutexType>*)param;
> > -  for (int i = 0; i < kIters; i++) {
> > -    if ((i % kWriteRate) == 0)
> > -      data->Write();
> > -    else
> > -      data->Read();
> > -    data->Backoff();
> > -  }
> > -  return 0;
> > -}
> > -
> > -TEST(Mutex, Write) {
> > -  Mutex mtx(MutexTypeAnnotations, StatMtxAnnotations);
> > -  TestData<Mutex> data(&mtx);
> > -  pthread_t threads[kThreads];
> > -  for (int i = 0; i < kThreads; i++)
> > -    pthread_create(&threads[i], 0, write_mutex_thread<Mutex>, &data);
> > -  for (int i = 0; i < kThreads; i++)
> > -    pthread_join(threads[i], 0);
> > -}
> > -
> > -TEST(Mutex, ReadWrite) {
> > -  Mutex mtx(MutexTypeAnnotations, StatMtxAnnotations);
> > -  TestData<Mutex> data(&mtx);
> > -  pthread_t threads[kThreads];
> > -  for (int i = 0; i < kThreads; i++)
> > -    pthread_create(&threads[i], 0, read_mutex_thread<Mutex>, &data);
> > -  for (int i = 0; i < kThreads; i++)
> > -    pthread_join(threads[i], 0);
> > -}
> > -
> > -TEST(Mutex, SpinWrite) {
> > -  SpinMutex mtx;
> > -  TestData<SpinMutex> data(&mtx);
> > -  pthread_t threads[kThreads];
> > -  for (int i = 0; i < kThreads; i++)
> > -    pthread_create(&threads[i], 0, write_mutex_thread<SpinMutex>,
> &data);
> > -  for (int i = 0; i < kThreads; i++)
> > -    pthread_join(threads[i], 0);
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_platform_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_platform_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_platform_test.cc
> (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_platform_test.cc (removed)
> > @@ -1,88 +0,0 @@
> > -//===-- tsan_platform_test.cc
> ---------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "sanitizer_common/sanitizer_libc.h"
> > -#include "tsan_platform.h"
> > -#include "gtest/gtest.h"
> > -
> > -namespace __tsan {
> > -
> > -static void TestThreadInfo(bool main) {
> > -  ScopedInRtl in_rtl;
> > -  uptr stk_addr = 0;
> > -  uptr stk_size = 0;
> > -  uptr tls_addr = 0;
> > -  uptr tls_size = 0;
> > -  GetThreadStackAndTls(main, &stk_addr, &stk_size, &tls_addr,
> &tls_size);
> > -  // Printf("stk=%zx-%zx(%zu)\n", stk_addr, stk_addr + stk_size,
> stk_size);
> > -  // Printf("tls=%zx-%zx(%zu)\n", tls_addr, tls_addr + tls_size,
> tls_size);
> > -
> > -  int stack_var;
> > -  EXPECT_NE(stk_addr, (uptr)0);
> > -  EXPECT_NE(stk_size, (uptr)0);
> > -  EXPECT_GT((uptr)&stack_var, stk_addr);
> > -  EXPECT_LT((uptr)&stack_var, stk_addr + stk_size);
> > -
> > -  static __thread int thread_var;
> > -  EXPECT_NE(tls_addr, (uptr)0);
> > -  EXPECT_NE(tls_size, (uptr)0);
> > -  EXPECT_GT((uptr)&thread_var, tls_addr);
> > -  EXPECT_LT((uptr)&thread_var, tls_addr + tls_size);
> > -
> > -  // Ensure that tls and stack do not intersect.
> > -  uptr tls_end = tls_addr + tls_size;
> > -  EXPECT_TRUE(tls_addr < stk_addr || tls_addr >= stk_addr + stk_size);
> > -  EXPECT_TRUE(tls_end  < stk_addr || tls_end  >=  stk_addr + stk_size);
> > -  EXPECT_TRUE((tls_addr < stk_addr) == (tls_end  < stk_addr));
> > -}
> > -
> > -static void *WorkerThread(void *arg) {
> > -  TestThreadInfo(false);
> > -  return 0;
> > -}
> > -
> > -TEST(Platform, ThreadInfoMain) {
> > -  TestThreadInfo(true);
> > -}
> > -
> > -TEST(Platform, ThreadInfoWorker) {
> > -  pthread_t t;
> > -  pthread_create(&t, 0, WorkerThread, 0);
> > -  pthread_join(t, 0);
> > -}
> > -
> > -TEST(Platform, FileOps) {
> > -  const char *str1 = "qwerty";
> > -  uptr len1 = internal_strlen(str1);
> > -  const char *str2 = "zxcv";
> > -  uptr len2 = internal_strlen(str2);
> > -
> > -  fd_t fd = internal_open("./tsan_test.tmp", true);
> > -  EXPECT_NE(fd, kInvalidFd);
> > -  EXPECT_EQ(len1, internal_write(fd, str1, len1));
> > -  EXPECT_EQ(len2, internal_write(fd, str2, len2));
> > -  internal_close(fd);
> > -
> > -  fd = internal_open("./tsan_test.tmp", false);
> > -  EXPECT_NE(fd, kInvalidFd);
> > -  EXPECT_EQ(len1 + len2, internal_filesize(fd));
> > -  char buf[64] = {};
> > -  EXPECT_EQ(len1, internal_read(fd, buf, len1));
> > -  EXPECT_EQ(0, internal_memcmp(buf, str1, len1));
> > -  EXPECT_EQ((char)0, buf[len1 + 1]);
> > -  internal_memset(buf, 0, len1);
> > -  EXPECT_EQ(len2, internal_read(fd, buf, len2));
> > -  EXPECT_EQ(0, internal_memcmp(buf, str2, len2));
> > -  internal_close(fd);
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_printf_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_printf_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_printf_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_printf_test.cc (removed)
> > @@ -1,106 +0,0 @@
> > -//===-- tsan_printf_test.cc
> -----------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_rtl.h"
> > -#include "gtest/gtest.h"
> > -
> > -#include <string.h>
> > -#include <limits.h>
> > -
> > -namespace __tsan {
> > -
> > -TEST(Printf, Basic) {
> > -  char buf[1024];
> > -  uptr len = internal_snprintf(buf, sizeof(buf),
> > -      "a%db%zdc%ue%zuf%xh%zxq%pe%sr",
> > -      (int)-1, (long)-2, // NOLINT
> > -      (unsigned)-4, (unsigned long)5, // NOLINT
> > -      (unsigned)10, (unsigned long)11, // NOLINT
> > -      (void*)0x123, "_string_");
> > -  EXPECT_EQ(len, strlen(buf));
> > -  EXPECT_EQ(0, strcmp(buf, "a-1b-2c4294967292e5fahbq"
> > -                           "0x000000000123e_string_r"));
> > -}
> > -
> > -TEST(Printf, OverflowStr) {
> > -  char buf[] = "123456789";
> > -  uptr len = internal_snprintf(buf, 4, "%s", "abcdef");  // NOLINT
> > -  EXPECT_EQ(len, (uptr)6);
> > -  EXPECT_EQ(0, strcmp(buf, "abc"));
> > -  EXPECT_EQ(buf[3], 0);
> > -  EXPECT_EQ(buf[4], '5');
> > -  EXPECT_EQ(buf[5], '6');
> > -  EXPECT_EQ(buf[6], '7');
> > -  EXPECT_EQ(buf[7], '8');
> > -  EXPECT_EQ(buf[8], '9');
> > -  EXPECT_EQ(buf[9], 0);
> > -}
> > -
> > -TEST(Printf, OverflowInt) {
> > -  char buf[] = "123456789";
> > -  internal_snprintf(buf, 4, "%d", -123456789);  // NOLINT
> > -  EXPECT_EQ(0, strcmp(buf, "-12"));
> > -  EXPECT_EQ(buf[3], 0);
> > -  EXPECT_EQ(buf[4], '5');
> > -  EXPECT_EQ(buf[5], '6');
> > -  EXPECT_EQ(buf[6], '7');
> > -  EXPECT_EQ(buf[7], '8');
> > -  EXPECT_EQ(buf[8], '9');
> > -  EXPECT_EQ(buf[9], 0);
> > -}
> > -
> > -TEST(Printf, OverflowUint) {
> > -  char buf[] = "123456789";
> > -  internal_snprintf(buf, 4, "a%zx", (unsigned long)0x123456789);  //
> NOLINT
> > -  EXPECT_EQ(0, strcmp(buf, "a12"));
> > -  EXPECT_EQ(buf[3], 0);
> > -  EXPECT_EQ(buf[4], '5');
> > -  EXPECT_EQ(buf[5], '6');
> > -  EXPECT_EQ(buf[6], '7');
> > -  EXPECT_EQ(buf[7], '8');
> > -  EXPECT_EQ(buf[8], '9');
> > -  EXPECT_EQ(buf[9], 0);
> > -}
> > -
> > -TEST(Printf, OverflowPtr) {
> > -  char buf[] = "123456789";
> > -  internal_snprintf(buf, 4, "%p", (void*)0x123456789);  // NOLINT
> > -  EXPECT_EQ(0, strcmp(buf, "0x0"));
> > -  EXPECT_EQ(buf[3], 0);
> > -  EXPECT_EQ(buf[4], '5');
> > -  EXPECT_EQ(buf[5], '6');
> > -  EXPECT_EQ(buf[6], '7');
> > -  EXPECT_EQ(buf[7], '8');
> > -  EXPECT_EQ(buf[8], '9');
> > -  EXPECT_EQ(buf[9], 0);
> > -}
> > -
> > -template<typename T>
> > -static void TestMinMax(const char *fmt, T min, T max) {
> > -  char buf[1024];
> > -  uptr len = internal_snprintf(buf, sizeof(buf), fmt, min, max);
> > -  char buf2[1024];
> > -  snprintf(buf2, sizeof(buf2), fmt, min, max);
> > -  EXPECT_EQ(len, strlen(buf));
> > -  EXPECT_EQ(0, strcmp(buf, buf2));
> > -}
> > -
> > -TEST(Printf, MinMax) {
> > -  TestMinMax<int>("%d-%d", INT_MIN, INT_MAX);  // NOLINT
> > -  TestMinMax<long>("%zd-%zd", LONG_MIN, LONG_MAX);  // NOLINT
> > -  TestMinMax<unsigned>("%u-%u", 0, UINT_MAX);  // NOLINT
> > -  TestMinMax<unsigned long>("%zu-%zu", 0, ULONG_MAX);  // NOLINT
> > -  TestMinMax<unsigned>("%x-%x", 0, UINT_MAX);  // NOLINT
> > -  TestMinMax<unsigned long>("%zx-%zx", 0, ULONG_MAX);  // NOLINT
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_shadow_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_shadow_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_shadow_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_shadow_test.cc (removed)
> > @@ -1,47 +0,0 @@
> > -//===-- tsan_shadow_test.cc
> -----------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_platform.h"
> > -#include "gtest/gtest.h"
> > -
> > -namespace __tsan {
> > -
> > -TEST(Shadow, Mapping) {
> > -  static int global;
> > -  int stack;
> > -  void *heap = malloc(0);
> > -  free(heap);
> > -
> > -  CHECK(IsAppMem((uptr)&global));
> > -  CHECK(IsAppMem((uptr)&stack));
> > -  CHECK(IsAppMem((uptr)heap));
> > -
> > -  CHECK(IsShadowMem(MemToShadow((uptr)&global)));
> > -  CHECK(IsShadowMem(MemToShadow((uptr)&stack)));
> > -  CHECK(IsShadowMem(MemToShadow((uptr)heap)));
> > -}
> > -
> > -TEST(Shadow, Celling) {
> > -  u64 aligned_data[4];
> > -  char *data = (char*)aligned_data;
> > -  CHECK_EQ((uptr)data % kShadowSize, 0);
> > -  uptr s0 = MemToShadow((uptr)&data[0]);
> > -  CHECK_EQ(s0 % kShadowSize, 0);
> > -  for (unsigned i = 1; i < kShadowCell; i++)
> > -    CHECK_EQ(s0, MemToShadow((uptr)&data[i]));
> > -  for (unsigned i = kShadowCell; i < 2*kShadowCell; i++)
> > -    CHECK_EQ(s0 + kShadowSize*kShadowCnt, MemToShadow((uptr)&data[i]));
> > -  for (unsigned i = 2*kShadowCell; i < 3*kShadowCell; i++)
> > -    CHECK_EQ(s0 + 2*kShadowSize*kShadowCnt,
> MemToShadow((uptr)&data[i]));
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_stack_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_stack_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_stack_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_stack_test.cc (removed)
> > @@ -1,80 +0,0 @@
> > -//===-- tsan_stack_test.cc
> ------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_sync.h"
> > -#include "tsan_rtl.h"
> > -#include "gtest/gtest.h"
> > -#include <string.h>
> > -
> > -namespace __tsan {
> > -
> > -static void TestStackTrace(StackTrace *trace) {
> > -  ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0);
> > -
> > -  trace->ObtainCurrent(&thr, 0);
> > -  EXPECT_EQ(trace->Size(), (uptr)0);
> > -
> > -  trace->ObtainCurrent(&thr, 42);
> > -  EXPECT_EQ(trace->Size(), (uptr)1);
> > -  EXPECT_EQ(trace->Get(0), (uptr)42);
> > -
> > -  *thr.shadow_stack_pos++ = 100;
> > -  *thr.shadow_stack_pos++ = 101;
> > -  trace->ObtainCurrent(&thr, 0);
> > -  EXPECT_EQ(trace->Size(), (uptr)2);
> > -  EXPECT_EQ(trace->Get(0), (uptr)100);
> > -  EXPECT_EQ(trace->Get(1), (uptr)101);
> > -
> > -  trace->ObtainCurrent(&thr, 42);
> > -  EXPECT_EQ(trace->Size(), (uptr)3);
> > -  EXPECT_EQ(trace->Get(0), (uptr)100);
> > -  EXPECT_EQ(trace->Get(1), (uptr)101);
> > -  EXPECT_EQ(trace->Get(2), (uptr)42);
> > -}
> > -
> > -TEST(StackTrace, Basic) {
> > -  ScopedInRtl in_rtl;
> > -  StackTrace trace;
> > -  TestStackTrace(&trace);
> > -}
> > -
> > -TEST(StackTrace, StaticBasic) {
> > -  ScopedInRtl in_rtl;
> > -  uptr buf[10];
> > -  StackTrace trace1(buf, 10);
> > -  TestStackTrace(&trace1);
> > -  StackTrace trace2(buf, 3);
> > -  TestStackTrace(&trace2);
> > -}
> > -
> > -TEST(StackTrace, StaticTrim) {
> > -  ScopedInRtl in_rtl;
> > -  uptr buf[2];
> > -  StackTrace trace(buf, 2);
> > -  ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0);
> > -
> > -  *thr.shadow_stack_pos++ = 100;
> > -  *thr.shadow_stack_pos++ = 101;
> > -  *thr.shadow_stack_pos++ = 102;
> > -  trace.ObtainCurrent(&thr, 0);
> > -  EXPECT_EQ(trace.Size(), (uptr)2);
> > -  EXPECT_EQ(trace.Get(0), (uptr)101);
> > -  EXPECT_EQ(trace.Get(1), (uptr)102);
> > -
> > -  trace.ObtainCurrent(&thr, 42);
> > -  EXPECT_EQ(trace.Size(), (uptr)2);
> > -  EXPECT_EQ(trace.Get(0), (uptr)102);
> > -  EXPECT_EQ(trace.Get(1), (uptr)42);
> > -}
> > -
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_suppressions_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_suppressions_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_suppressions_test.cc
> (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_suppressions_test.cc
> (removed)
> > @@ -1,128 +0,0 @@
> > -//===-- tsan_suppressions_test.cc
> -----------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_suppressions.h"
> > -#include "tsan_rtl.h"
> > -#include "gtest/gtest.h"
> > -
> > -#include <string.h>
> > -
> > -namespace __tsan {
> > -
> > -TEST(Suppressions, Parse) {
> > -  ScopedInRtl in_rtl;
> > -  Suppression *supp0 = SuppressionParse(
> > -    "race:foo\n"
> > -    "  race:bar\n"  // NOLINT
> > -    "race:baz   \n"  // NOLINT
> > -    "# a comment\n"
> > -    "race:quz\n"
> > -  );  // NOLINT
> > -  Suppression *supp = supp0;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "quz"));
> > -  supp = supp->next;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "baz"));
> > -  supp = supp->next;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "bar"));
> > -  supp = supp->next;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "foo"));
> > -  supp = supp->next;
> > -  EXPECT_EQ((Suppression*)0, supp);
> > -}
> > -
> > -TEST(Suppressions, Parse2) {
> > -  ScopedInRtl in_rtl;
> > -  Suppression *supp0 = SuppressionParse(
> > -    "          # first line comment\n"  // NOLINT
> > -    "  race:bar        \n"  // NOLINT
> > -    "race:baz* *baz\n"
> > -    "# a comment\n"
> > -    "# last line comment\n"
> > -  );  // NOLINT
> > -  Suppression *supp = supp0;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "baz* *baz"));
> > -  supp = supp->next;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "bar"));
> > -  supp = supp->next;
> > -  EXPECT_EQ((Suppression*)0, supp);
> > -}
> > -
> > -TEST(Suppressions, Parse3) {
> > -  ScopedInRtl in_rtl;
> > -  Suppression *supp0 = SuppressionParse(
> > -    "# last suppression w/o line-feed\n"
> > -    "race:foo\n"
> > -    "race:bar"
> > -  );  // NOLINT
> > -  Suppression *supp = supp0;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "bar"));
> > -  supp = supp->next;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "foo"));
> > -  supp = supp->next;
> > -  EXPECT_EQ((Suppression*)0, supp);
> > -}
> > -
> > -TEST(Suppressions, ParseType) {
> > -  ScopedInRtl in_rtl;
> > -  Suppression *supp0 = SuppressionParse(
> > -    "race:foo\n"
> > -    "thread:bar\n"
> > -    "mutex:baz\n"
> > -    "signal:quz\n"
> > -  );  // NOLINT
> > -  Suppression *supp = supp0;
> > -  EXPECT_EQ(supp->type, SuppressionSignal);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "quz"));
> > -  supp = supp->next;
> > -  EXPECT_EQ(supp->type, SuppressionMutex);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "baz"));
> > -  supp = supp->next;
> > -  EXPECT_EQ(supp->type, SuppressionThread);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "bar"));
> > -  supp = supp->next;
> > -  EXPECT_EQ(supp->type, SuppressionRace);
> > -  EXPECT_EQ(0, strcmp(supp->templ, "foo"));
> > -  supp = supp->next;
> > -  EXPECT_EQ((Suppression*)0, supp);
> > -}
> > -
> > -static bool MyMatch(const char *templ, const char *func) {
> > -  char tmp[1024];
> > -  strcpy(tmp, templ);  // NOLINT
> > -  return SuppressionMatch(tmp, func);
> > -}
> > -
> > -TEST(Suppressions, Match) {
> > -  EXPECT_TRUE(MyMatch("foobar", "foobar"));
> > -  EXPECT_TRUE(MyMatch("foobar", "prefix_foobar_postfix"));
> > -  EXPECT_TRUE(MyMatch("*foobar*", "prefix_foobar_postfix"));
> > -  EXPECT_TRUE(MyMatch("foo*bar", "foo_middle_bar"));
> > -  EXPECT_TRUE(MyMatch("foo*bar", "foobar"));
> > -  EXPECT_TRUE(MyMatch("foo*bar*baz", "foo_middle_bar_another_baz"));
> > -  EXPECT_TRUE(MyMatch("foo*bar*baz", "foo_middle_barbaz"));
> > -
> > -  EXPECT_FALSE(MyMatch("foo", "baz"));
> > -  EXPECT_FALSE(MyMatch("foobarbaz", "foobar"));
> > -  EXPECT_FALSE(MyMatch("foobarbaz", "barbaz"));
> > -  EXPECT_FALSE(MyMatch("foo*bar", "foobaz"));
> > -  EXPECT_FALSE(MyMatch("foo*bar", "foo_baz"));
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_sync_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_sync_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_sync_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_sync_test.cc (removed)
> > @@ -1,65 +0,0 @@
> > -//===-- tsan_sync_test.cc
> -------------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_sync.h"
> > -#include "tsan_rtl.h"
> > -#include "tsan_mman.h"
> > -#include "gtest/gtest.h"
> > -
> > -#include <stdlib.h>
> > -#include <stdint.h>
> > -#include <map>
> > -
> > -namespace __tsan {
> > -
> > -TEST(Sync, Table) {
> > -  const uintptr_t kIters = 512*1024;
> > -  const uintptr_t kRange = 10000;
> > -
> > -  ScopedInRtl in_rtl;
> > -  ThreadState *thr = cur_thread();
> > -  uptr pc = 0;
> > -
> > -  SyncTab tab;
> > -  SyncVar *golden[kRange] = {};
> > -  unsigned seed = 0;
> > -  for (uintptr_t i = 0; i < kIters; i++) {
> > -    uintptr_t addr = rand_r(&seed) % (kRange - 1) + 1;
> > -    if (rand_r(&seed) % 2) {
> > -      // Get or add.
> > -      SyncVar *v = tab.GetAndLock(thr, pc, addr, true);
> > -      EXPECT_TRUE(golden[addr] == 0 || golden[addr] == v);
> > -      EXPECT_EQ(v->addr, addr);
> > -      golden[addr] = v;
> > -      v->mtx.Unlock();
> > -    } else {
> > -      // Remove.
> > -      SyncVar *v = tab.GetAndRemove(thr, pc, addr);
> > -      EXPECT_EQ(golden[addr], v);
> > -      if (v) {
> > -        EXPECT_EQ(v->addr, addr);
> > -        golden[addr] = 0;
> > -        DestroyAndFree(v);
> > -      }
> > -    }
> > -  }
> > -  for (uintptr_t addr = 0; addr < kRange; addr++) {
> > -    if (golden[addr] == 0)
> > -      continue;
> > -    SyncVar *v = tab.GetAndRemove(thr, pc, addr);
> > -    EXPECT_EQ(v, golden[addr]);
> > -    EXPECT_EQ(v->addr, addr);
> > -    DestroyAndFree(v);
> > -  }
> > -}
> > -
> > -}  // namespace __tsan
> >
> > Removed: compiler-rt/trunk/lib/tsan/unit_tests/tsan_vector_test.cc
> > URL:
> http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/tsan/unit_tests/tsan_vector_test.cc?rev=164021&view=auto
> >
> ==============================================================================
> > --- compiler-rt/trunk/lib/tsan/unit_tests/tsan_vector_test.cc (original)
> > +++ compiler-rt/trunk/lib/tsan/unit_tests/tsan_vector_test.cc (removed)
> > @@ -1,45 +0,0 @@
> > -//===-- tsan_vector_test.cc
> -----------------------------------------------===//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file is a part of ThreadSanitizer (TSan), a race detector.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#include "tsan_vector.h"
> > -#include "tsan_rtl.h"
> > -#include "gtest/gtest.h"
> > -
> > -namespace __tsan {
> > -
> > -TEST(Vector, Basic) {
> > -  ScopedInRtl in_rtl;
> > -  Vector<int> v(MBlockScopedBuf);
> > -  EXPECT_EQ(v.Size(), (uptr)0);
> > -  v.PushBack(42);
> > -  EXPECT_EQ(v.Size(), (uptr)1);
> > -  EXPECT_EQ(v[0], 42);
> > -  v.PushBack(43);
> > -  EXPECT_EQ(v.Size(), (uptr)2);
> > -  EXPECT_EQ(v[0], 42);
> > -  EXPECT_EQ(v[1], 43);
> > -}
> > -
> > -TEST(Vector, Stride) {
> > -  ScopedInRtl in_rtl;
> > -  Vector<int> v(MBlockScopedBuf);
> > -  for (int i = 0; i < 1000; i++) {
> > -    v.PushBack(i);
> > -    EXPECT_EQ(v.Size(), (uptr)(i + 1));
> > -    EXPECT_EQ(v[i], i);
> > -  }
> > -  for (int i = 0; i < 1000; i++) {
> > -    EXPECT_EQ(v[i], i);
> > -  }
> > -}
> > -
> > -}  // namespace __tsan
> >
> >
> > _______________________________________________
> > llvm-commits mailing list
> > llvm-commits at cs.uiuc.edu
> > http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>



-- 
Alexey Samsonov, MSK
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20120918/bf6a3a83/attachment.html>


More information about the llvm-commits mailing list