Beta 3

clang/lib/Driver/ToolChains/Clang.cpp

@@ -4524,16 +4524,34 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
     if (!Triple.isOSLinux() && !Triple.isOSFreeBSD() && !Triple.isMacOSX())
       D.Diag(diag::err_drv_cilk_unsupported);
 
+    /* JFC: Is it possible to confuse with with -fno-opencilk? */
+    bool OpenCilk = Args.hasArgNoClaim(options::OPT_fopencilk);
+    bool Cheetah = false;
+
     if (Arg *TapirRuntime = Args.getLastArgNoClaim(options::OPT_ftapir_EQ)) {
-      // Cheetah runtime is x86 only.
-      if (TapirRuntime->getValue() == StringRef("cheetah")) {
-	if (Triple.getArch() != llvm::Triple::x86_64)
-	  D.Diag(diag::err_drv_cilk_unsupported);
-      }
-      // OpenCilk will additionally support 64 bit ARM.
+      Cheetah = TapirRuntime->getValue() == StringRef("cheetah");
       if (TapirRuntime->getValue() == StringRef("opencilk")) {
-	if (Triple.getArch() != llvm::Triple::x86_64 && !Triple.isAArch64())
-	  D.Diag(diag::err_drv_cilk_unsupported);
+        OpenCilk = true;
+      }
+    }
+
+    if (Cheetah && Triple.getArch() != llvm::Triple::x86_64) {
+      D.Diag(diag::err_drv_cilk_unsupported);
+    }
+    if (OpenCilk) {
+      switch (Triple.getArch()) {
+      case llvm::Triple::x86:
+      case llvm::Triple::x86_64:
+      case llvm::Triple::arm:
+      case llvm::Triple::armeb:
+	break;
+      case llvm::Triple::aarch64:
+      case llvm::Triple::aarch64_be:
+      case llvm::Triple::aarch64_32:
+	/* ARMv8 is waiting on builtin setjmp/longjmp. */
+      default:
+	D.Diag(diag::err_drv_cilk_unsupported);
+	break;
       }
     }
   }

clang/lib/Driver/ToolChains/CommonArgs.cpp

@@ -769,6 +769,11 @@ bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
   if (SanArgs.hasCrossDsoCfi() && !AddExportDynamic)
     CmdArgs.push_back("-export-dynamic-symbol=__cfi_check");
 
+  if (SanArgs.needsCilksanRt())
+    // Interpose the __cilkrts_internal_merge_two_rmaps function in the OpenCilk
+    // runtime, to properly suppress races involving reducer hyperobjects.
+    CmdArgs.push_back("--wrap=__cilkrts_internal_merge_two_rmaps");
+
   return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();
 }
 

clang/test/Cilk/cilksan-O0.c

@@ -12,27 +12,27 @@ int c = 2;
 
 void addA() {
   // CHECK: define void @addA()
-  // CHECK: __csan_func_entry(i64 {{.+}}, i8* {{.+}}, i64 0)
+  // CHECK: __csan_func_entry(i64 {{.+}}, i8* {{.+}}, i8* {{.+}}, i64 0)
   a = c;
 }
 
 void addB() {
   // CHECK: define void @addB()
-  // CHECK: __csan_func_entry(i64 {{.+}}, i8* {{.+}}, i64 0)
+  // CHECK: __csan_func_entry(i64 {{.+}}, i8* {{.+}}, i8* {{.+}}, i64 0)
   b = a;
 }
 
 void foo() {
   // CHECK: define void @foo()
-  // CHECK: __csan_func_entry(i64 {{.+}}, i8* {{.+}}, i64 3)
+  // CHECK: __csan_func_entry(i64 {{.+}}, i8* {{.+}}, i8* {{.+}}, i64 257)
   _Cilk_spawn addA();
   addB();
   _Cilk_sync;
 }
 
 int main() {
   // CHECK: define i32 @main()
-  // CHECK: __csan_func_entry(i64 {{.+}}, i8* {{.+}}, i64 0)
+  // CHECK: __csan_func_entry(i64 {{.+}}, i8* {{.+}}, i8* {{.+}}, i64 0)
   foo();
   return 0;
 }

compiler-rt/include/csi/csi.h

@@ -50,10 +50,10 @@ typedef struct {
 // Property bitfields.
 
 typedef struct {
-  // The function might spawn.
-  unsigned may_spawn : 1;
   // Number of sync regions in this function.
   unsigned num_sync_reg : 8;
+  // The function might spawn.
+  unsigned may_spawn : 1;
   // Pad struct to 64 total bits.
   uint64_t _padding : 55;
 } func_prop_t;

compiler-rt/lib/cilksan/CMakeLists.txt

@@ -15,10 +15,9 @@ include_directories(${COMPILER_RT_SOURCE_DIR}/include)
 
 set(CILKSAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_list_if(COMPILER_RT_HAS_STD_CXX11_FLAG -std=c++11 CILKSAN_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions CILKSAN_CFLAGS)
 append_rtti_flag(OFF CILKSAN_CFLAGS)
 
-set(CILKSAN_DYNAMIC_LINK_FLAGS)
-
 set(CILKSAN_DYNAMIC_DEFINITIONS
   ${CILKSAN_COMMON_DEFINITIONS} CILKSAN_DYNAMIC=1)
 
@@ -36,6 +35,15 @@ append_list_if(COMPILER_RT_HAS_LIBDL dl CILKSAN_DYNAMIC_LIBS)
 #append_list_if(COMPILER_RT_HAS_LIBSTDCXX stdc++ CILKSAN_DYNAMIC_LIBS)
 #append_list_if(COMPILER_RT_HAS_LIBLOG log CILKSAN_DYNAMIC_LIBS)
 
+set(CILKSAN_COMMON_LINK_FLAGS)
+append_list_if(COMPILER_RT_HAS_CILK_FLAG -fopencilk CILKSAN_COMMON_LINK_FLAGS)
+
+set(CILKSAN_STATIC_LINK_FLAGS ${CILKSAN_COMMON_LINK_FLAGS})
+append_list_if(COMPILER_RT_HAS_CILK_FLAG
+  -Wl,--wrap,__cilkrts_internal_merge_two_rmaps CILKSAN_STATIC_LINK_FLAGS)
+
+set(CILKSAN_DYNAMIC_LINK_FLAGS ${CILKSAN_COMMON_LINK_FLAGS})
+
 # Build Cilksan runtimes shipped with Clang.
 add_compiler_rt_component(cilksan)
 
@@ -61,6 +69,7 @@ if (APPLE)
     ARCHS ${CILKSAN_SUPPORTED_ARCH}
     OBJECT_LIBS RTCilksan
     CFLAGS ${CILKSAN_CFLAGS}
+    LINK_FLAGS ${CILKSAN_STATIC_LINK_FLAGS}
     DEFS ${CILKSAN_COMMON_DEFINITIONS}
     PARENT_TARGET cilksan)
 
@@ -95,6 +104,7 @@ else() # Not APPLE
       ARCHS ${arch}
       OBJECT_LIBS RTCilksan
       CFLAGS ${CILKSAN_CFLAGS}
+      LINK_FLAGS ${CILKSAN_STATIC_LINK_FLAGS}
       DEFS ${CILKSAN_COMMON_DEFINITIONS}
       PARENT_TARGET cilksan)
 

compiler-rt/lib/cilksan/cilksan.cpp

@@ -80,19 +80,19 @@ call_stack_node_t *call_stack_node_t::free_list = nullptr;
 CilkSanImpl_t CilkSanImpl;
 
 // Initialize custom memory allocators for dictionaries in shadow memory.
-template<>
-MALineAllocator &SimpleDictionary<0>::MAAlloc =
-  CilkSanImpl.getMALineAllocator(0);
-template<>
-MALineAllocator &SimpleDictionary<1>::MAAlloc =
-  CilkSanImpl.getMALineAllocator(1);
-template<>
-MALineAllocator &SimpleDictionary<2>::MAAlloc =
-  CilkSanImpl.getMALineAllocator(2);
-
-template<>
-DisjointSet_t<SPBagInterface *>::DJSAllocator
-&DisjointSet_t<SPBagInterface *>::Alloc = CilkSanImpl.getDJSAllocator();
+template <>
+MALineAllocator &
+    SimpleDictionary<0>::MAAlloc = CilkSanImpl.getMALineAllocator(0);
+template <>
+MALineAllocator &
+    SimpleDictionary<1>::MAAlloc = CilkSanImpl.getMALineAllocator(1);
+template <>
+MALineAllocator &
+    SimpleDictionary<2>::MAAlloc = CilkSanImpl.getMALineAllocator(2);
+
+template <>
+DisjointSet_t<SPBagInterface *>::DJSAllocator &
+    DisjointSet_t<SPBagInterface *>::Alloc = CilkSanImpl.getDJSAllocator();
 
 ////////////////////////////////////////////////////////////////////////
 // Events functions
@@ -243,6 +243,7 @@ inline void CilkSanImpl_t::start_new_function(unsigned num_sync_reg) {
   FrameData_t *child = frame_stack.head();
   cilksan_assert(child->Sbag == NULL);
   cilksan_assert(child->Pbags == NULL);
+  cilksan_assert(child->num_Pbags == 0);
 
   DBG_TRACE(DEBUG_BAGS, "Creating SBag for frame %ld\n", frame_id);
   child_sbag =
@@ -251,7 +252,8 @@ inline void CilkSanImpl_t::start_new_function(unsigned num_sync_reg) {
   child->init_new_function(child_sbag);
 
   if (num_sync_reg > 0) {
-    DBG_TRACE(DEBUG_BAGS, "Creating PBag array for frame %ld\n", frame_id);
+    DBG_TRACE(DEBUG_BAGS, "Creating PBag array of size %d for frame %ld\n",
+              num_sync_reg, frame_id);
     child->make_pbag_array(num_sync_reg);
   } else {
     DBG_TRACE(DEBUG_BAGS, "Skipping PBag-array creation for frame %ld\n", frame_id);
@@ -325,6 +327,8 @@ inline void CilkSanImpl_t::complete_sync(unsigned sync_reg) {
   cilksan_assert(f->Sbag->get_set_node()->is_SBag());
   // Pbag could be NULL if we encounter a sync without any spawn (i.e., any Cilk
   // function that executes the base case)
+  cilksan_assert(sync_reg < f->num_Pbags && "Invalid sync_reg");
+  cilksan_assert(f->Pbags && "Cannot sync NULL pbags array");
   if (f->Pbags[sync_reg]) {
     DBG_TRACE(DEBUG_BAGS,
               "Merge P-bag %d (%p) in frame %ld into S-bag.\n", sync_reg,
@@ -386,12 +390,16 @@ void CilkSanImpl_t::do_enter_end(uintptr_t stack_ptr) {
   cilksan_assert(last_event == ENTER_FRAME || last_event == ENTER_HELPER);
   WHEN_CILKSAN_DEBUG(last_event = NONE);
   DBG_TRACE(DEBUG_CALLBACK, "cilk_enter_end, frame stack ptr: %p\n", stack_ptr);
+
 }
 
 void CilkSanImpl_t::do_detach_begin() {
   cilksan_assert(CILKSAN_INITIALIZED);
   cilksan_assert(last_event == NONE);
   WHEN_CILKSAN_DEBUG(last_event = DETACH);
+
+  update_strand_stats();
+  shadow_memory.clearOccupied();
 }
 
 void CilkSanImpl_t::do_detach_end() {
@@ -420,6 +428,14 @@ void CilkSanImpl_t::do_detach_end() {
   // enter_detach_child();
 }
 
+void CilkSanImpl_t::do_detach_continue() {
+  cilksan_assert(CILKSAN_INITIALIZED);
+  DBG_TRACE(DEBUG_CALLBACK, "cilk_detach_continue\n");
+
+  update_strand_stats();
+  shadow_memory.clearOccupied();
+}
+
 void CilkSanImpl_t::do_loop_iteration_begin(uintptr_t stack_ptr,
                                             unsigned num_sync_reg) {
   DBG_TRACE(DEBUG_CALLBACK, "do_loop_iteration_begin()\n");
@@ -449,13 +465,19 @@ void CilkSanImpl_t::do_loop_iteration_begin(uintptr_t stack_ptr,
     cilksan_assert(in_loop());
     func->Sbag->get_node()->set_rsp(stack_ptr);
     func->Iterbag->get_node()->set_rsp(stack_ptr);
+
+    update_strand_stats();
+    shadow_memory.clearOccupied();
   }
 }
 
 void CilkSanImpl_t::do_loop_iteration_end() {
   // frame_stack.head()->Sbag->set_version(
   //     frame_stack.head()->Sbag->get_node()->get_version());
 
+  update_strand_stats();
+  shadow_memory.clearOccupied();
+
   // At the end of each iteration, update the LOOP_FRAME for reuse.
   DBG_TRACE(DEBUG_CALLBACK, "do_loop_iteration_end()\n");
   FrameData_t *func = frame_stack.head();
@@ -556,6 +578,9 @@ void CilkSanImpl_t::do_sync_begin() {
             frame_stack.head()->Sbag->get_node()->get_func_id());
   cilksan_assert(last_event == NONE);
   WHEN_CILKSAN_DEBUG(last_event = CILK_SYNC);
+
+  update_strand_stats();
+  shadow_memory.clearOccupied();
 }
 
 void CilkSanImpl_t::do_sync_end(unsigned sync_reg) {
@@ -574,6 +599,7 @@ void CilkSanImpl_t::do_leave_begin(unsigned sync_reg) {
             frame_stack.head()->frame_data.frame_id);
   cilksan_assert(frame_stack.size() > 1);
 
+
   switch(frame_stack.head()->frame_data.entry_type) {
   case SPAWNER:
     DBG_TRACE(DEBUG_CALLBACK, "cilk_leave_frame_begin\n");
@@ -605,6 +631,13 @@ template<bool is_read>
 inline void
 CilkSanImpl_t::record_mem_helper(const csi_id_t acc_id, uintptr_t addr,
                                  size_t mem_size, bool on_stack) {
+  // Do nothing for 0-byte accesses
+  if (!mem_size)
+    return;
+
+  if (!shadow_memory.setOccupied(is_read, addr, mem_size))
+    return;
+
   FrameData_t *f = frame_stack.head();
   bool write_in_shadow = shadow_memory.does_access_exists<false>(addr,
                                                                  mem_size);
@@ -746,7 +779,16 @@ void CilkSanImpl_t::do_read(const csi_id_t load_id,
   DBG_TRACE(DEBUG_MEMORY, "record read %lu: %lu bytes at addr %p and rip %p.\n",
             load_id, mem_size, addr,
             (load_id != UNKNOWN_CSI_ID) ? load_pc[load_id] : 0);
-  ++num_reads_checked;
+  if (collect_stats) {
+    ++total_reads_checked;
+    if (!num_reads_checked.count(mem_size))
+      num_reads_checked.insert(std::make_pair(mem_size, 0));
+    ++num_reads_checked[mem_size];
+
+    if (!strand_num_reads_checked.count(mem_size))
+      strand_num_reads_checked.insert(std::make_pair(mem_size, 0));
+    ++strand_num_reads_checked[mem_size];
+  }
 
   bool on_stack = is_on_stack(addr);
   if (on_stack)
@@ -760,7 +802,16 @@ void CilkSanImpl_t::do_write(const csi_id_t store_id,
   cilksan_assert(CILKSAN_INITIALIZED);
   DBG_TRACE(DEBUG_MEMORY, "record write %ld: %lu bytes at addr %p and rip %p.\n",
             store_id, mem_size, addr, store_pc[store_id]);
-  ++num_writes_checked;
+  if (collect_stats) {
+    ++total_writes_checked;
+    if (!num_writes_checked.count(mem_size))
+      num_writes_checked.insert(std::make_pair(mem_size, 0));
+    ++num_writes_checked[mem_size];
+
+    if (!strand_num_writes_checked.count(mem_size))
+      strand_num_writes_checked.insert(std::make_pair(mem_size, 0));
+    ++strand_num_writes_checked[mem_size];
+  }
 
   bool on_stack = is_on_stack(addr);
   if (on_stack)
@@ -778,6 +829,8 @@ void CilkSanImpl_t::clear_shadow_memory(size_t start, size_t size) {
 
 void CilkSanImpl_t::record_alloc(size_t start, size_t size,
                                  csi_id_t alloca_id) {
+  if (!size)
+    return;
   DBG_TRACE(DEBUG_MEMORY, "cilksan_record_alloc(%p, %ld)\n",
             start, size);
   FrameData_t *f = frame_stack.head();
@@ -799,8 +852,24 @@ inline void CilkSanImpl_t::print_stats() {
   //           << std::endl;
   // std::cout << "max continuation depth seen: "
   //           << accounted_max_cont_depth << std::endl;
-  std::cout << "number of reads checked:  " << num_reads_checked << "\n";
-  std::cout << "number of writes checked: " << num_writes_checked << "\n";
+
+  std::cout << ",size (bytes),count\n";
+
+  for (std::pair<size_t, uint64_t> reads : num_reads_checked)
+    std::cout << "reads," << reads.first << "," << reads.second << "\n";
+  std::cout << "total reads,," << total_reads_checked << "\n";
+
+  for (std::pair<size_t, uint64_t> writes : num_writes_checked)
+    std::cout << "writes," << writes.first << "," << writes.second << "\n";
+  std::cout << "total writes,," << total_writes_checked << "\n";
+
+  std::cout << "total strands,," << strand_count << "\n";
+
+  for (std::pair<size_t, uint64_t> reads : max_num_reads_checked)
+    std::cout << "max reads," << reads.first << "," << reads.second << "\n";
+
+  for (std::pair<size_t, uint64_t> writes : max_num_writes_checked)
+    std::cout << "max writes," << writes.first << "," << writes.second << "\n";
 }
 
 void CilkSanImpl_t::deinit() {
@@ -811,8 +880,7 @@ void CilkSanImpl_t::deinit() {
 
   print_race_report();
   // Optionally print statistics.
-  char *e = getenv("CILKSAN_STATS");
-  if (e && 0 != strcmp(e, "0"))
+  if (collect_stats)
     print_stats();
 
   cilksan_assert(frame_stack.size() == 1);
@@ -857,6 +925,11 @@ void CilkSanImpl_t::deinit() {
 
 void CilkSanImpl_t::init() {
   DBG_TRACE(DEBUG_CALLBACK, "cilksan_init()\n");
+
+  char *e = getenv("CILKSAN_STATS");
+  if (e && 0 != strcmp(e, "0"))
+    collect_stats = true;
+
   std::cout << "Running Cilksan race detector\n";
   // std::cout << "cilksan_init() version 19\n";