[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