d8: Fix some TSAN bugs

src/d8.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 // Defined when linking against shared lib on Windows.
 #if defined(USING_V8_SHARED) && !defined(V8_SHARED)
 #define V8_SHARED
 #endif
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #ifdef V8_SHARED
 #include <assert.h>
 #endif  // V8_SHARED
 
 #ifndef V8_SHARED
 #include <algorithm>
+#include <vector>
 #endif  // !V8_SHARED
 
 #ifdef V8_SHARED
 #include "include/v8-testing.h"
 #endif  // V8_SHARED
 
 #if !defined(V8_SHARED) && defined(ENABLE_GDB_JIT_INTERFACE)
 #include "src/gdb-jit.h"
 #endif
 
@@ skipping 1573 matching lines @@
 
 
 void SerializationDataQueue::Enqueue(SerializationData* data) {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   data_.Add(data);
 }
 
 
 bool SerializationDataQueue::Dequeue(SerializationData** data) {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
+  *data = NULL;
   if (data_.is_empty()) return false;
   *data = data_.Remove(0);
   return true;
 }
 
 
 bool SerializationDataQueue::IsEmpty() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   return data_.is_empty();
 }
 
 
 void SerializationDataQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   for (int i = 0; i < data_.length(); ++i) {
     delete data_[i];
   }
   data_.Clear();
 }
 
 
 Worker::Worker()
     : in_semaphore_(0),
       out_semaphore_(0),
       thread_(NULL),
       script_(NULL),
-      state_(IDLE) {}
+      state_(IDLE),
+      join_called_(false) {}
 
 
 Worker::~Worker() { Cleanup(); }
 
 
 void Worker::StartExecuteInThread(Isolate* isolate, const char* script) {
   if (base::NoBarrier_CompareAndSwap(&state_, IDLE, RUNNING) == IDLE) {
     script_ = i::StrDup(script);
     thread_ = new WorkerThread(this);
     thread_->Start();
   } else {
     // Somehow the Worker was started twice.
     UNREACHABLE();
   }
 }
 
 
 void Worker::PostMessage(SerializationData* data) {
   in_queue_.Enqueue(data);
   in_semaphore_.Signal();
 }
 
 
 SerializationData* Worker::GetMessage() {
   SerializationData* data = NULL;
   while (!out_queue_.Dequeue(&data)) {
+    // If the worker is no longer running, and there are no messages in the
+    // queue, don't expect any more messages from it.
     if (base::NoBarrier_Load(&state_) != RUNNING) break;
     out_semaphore_.Wait();
   }
 
   return data;
 }
 
 
 void Worker::Terminate() {
   if (base::NoBarrier_CompareAndSwap(&state_, RUNNING, TERMINATED) == RUNNING) {
-    // Post NULL to wake the Worker thread message loop.
+    // Post NULL to wake the Worker thread message loop, and tell it to stop
+    // running.
     PostMessage(NULL);
-    thread_->Join();
   }
 }
 
+
+void Worker::WaitForThread() {
+  Terminate();
+
+  if (base::NoBarrier_CompareAndSwap(&join_called_, false, true) == false) {
+    thread_->Join();
+  } else {
+    // Tried to call join twice.
+    UNREACHABLE();
+  }
+}
+
 
 void Worker::ExecuteInThread() {
   Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = Shell::array_buffer_allocator;
   Isolate* isolate = Isolate::New(create_params);
   {
     Isolate::Scope iscope(isolate);
     {
       HandleScope scope(isolate);
       PerIsolateData data(isolate);
@@ skipping 17 matching lines @@
         // First run the script
         Handle<String> file_name = String::NewFromUtf8(isolate, "unnamed");
         Handle<String> source = String::NewFromUtf8(isolate, script_);
         if (Shell::ExecuteString(isolate, source, file_name, false, true)) {
           // Get the message handler
           Handle<Value> onmessage =
               global->Get(String::NewFromUtf8(isolate, "onmessage"));
           if (onmessage->IsFunction()) {
             Handle<Function> onmessage_fun = Handle<Function>::Cast(onmessage);
             // Now wait for messages
-            bool done = false;
-            while (!done) {
+            while (true) {
               in_semaphore_.Wait();
               SerializationData* data;
               if (!in_queue_.Dequeue(&data)) continue;
               if (data == NULL) {
-                done = true;
                 break;
               }
               int offset = 0;
               Local<Value> data_value;
               if (Shell::DeserializeValue(isolate, *data, &offset)
                       .ToLocal(&data_value)) {
                 Handle<Value> argv[] = {data_value};
                 (void)onmessage_fun->Call(context, global, 1, argv);
               }
               delete data;
             }
           }
         }
       }
     }
     Shell::CollectGarbage(isolate);
   }
   isolate->Dispose();
 
-  if (base::NoBarrier_CompareAndSwap(&state_, RUNNING, TERMINATED) == RUNNING) {
-    // Post NULL to wake the thread waiting on GetMessage() if there is one.
-    out_queue_.Enqueue(NULL);
-    out_semaphore_.Signal();
-  }
+  // Post NULL to wake the thread waiting on GetMessage() if there is one.
+  out_queue_.Enqueue(NULL);
+  out_semaphore_.Signal();
 }
 
 
 void Worker::Cleanup() {
   delete thread_;
   thread_ = NULL;
   delete[] script_;
   script_ = NULL;
   in_queue_.Clear();
   out_queue_.Clear();
@@ skipping 377 matching lines @@
       result = True(isolate);
       break;
     case kSerializationTagFalse:
       result = False(isolate);
       break;
     case kSerializationTagNumber:
       result = Number::New(isolate, data.Read<double>(offset));
       break;
     case kSerializationTagString: {
       int length = data.Read<int>(offset);
-      static char s_buffer[128];
-      char* p = s_buffer;
-      bool allocated = false;
-      if (length > static_cast<int>(sizeof(s_buffer))) {
-        p = new char[length];
-        allocated = true;
-      }
-      data.ReadMemory(p, length, offset);
-      MaybeLocal<String> str =
-          String::NewFromUtf8(isolate, p, String::kNormalString, length);
+      CHECK(length >= 0);
+      std::vector<char> buffer(length + 1);  // + 1 so it is never empty.
+      data.ReadMemory(&buffer[0], length, offset);
+      MaybeLocal<String> str = String::NewFromUtf8(
+          isolate, &buffer[0], String::kNormalString, length);
       if (!str.IsEmpty()) result = str.ToLocalChecked();
-      if (allocated) delete[] p;
       break;
     }
     case kSerializationTagArray: {
       uint32_t length = data.Read<uint32_t>(offset);
       Handle<Array> array = Array::New(isolate, length);
       for (uint32_t i = 0; i < length; ++i) {
         Local<Value> element_value;
         CHECK(DeserializeValue(isolate, data, offset).ToLocal(&element_value));
         array->Set(i, element_value);
       }
@@ skipping 51 matching lines @@
   i::List<Worker*> workers_copy;
   {
     base::LockGuard<base::Mutex> lock_guard(&workers_mutex_);
     allow_new_workers_ = false;
     workers_copy.AddAll(workers_);
     workers_.Clear();
   }
 
   for (int i = 0; i < workers_copy.length(); ++i) {
     Worker* worker = workers_copy[i];
-    worker->Terminate();
+    worker->WaitForThread();
     delete worker;
   }
 
   // Now that all workers are terminated, we can re-enable Worker creation.
   {
     base::LockGuard<base::Mutex> lock_guard(&workers_mutex_);
     allow_new_workers_ = true;
   }
 
   for (int i = 0; i < externalized_shared_contents_.length(); ++i) {
@@ skipping 196 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif