Fix tsan failure

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 400 matching lines @@
 
  protected:
   Isolate* isolate_;
   Sample* sample_;
   SampleBuffer* sample_buffer_;
   intptr_t frame_index_;
   intptr_t total_frames_;
 };
 
 
-// Given an exit frame, walk the Dart stack.
-class ProfilerDartExitStackWalker : public ProfilerStackWalker {
- public:
-  ProfilerDartExitStackWalker(Thread* thread,
-                              Isolate* isolate,
-                              Sample* sample,
-                              SampleBuffer* sample_buffer)
-      : ProfilerStackWalker(isolate, sample, sample_buffer),
-        frame_iterator_(thread) {}
-
-  void walk() {
-    // Mark that this sample was collected from an exit frame.
-    sample_->set_exit_frame_sample(true);
-
-    StackFrame* frame = frame_iterator_.NextFrame();
-    if (sample_ == NULL) {
-      // Only when we are dumping the stack trace for debug purposes.
-      Code& code = Code::Handle();
-      while (frame != NULL) {
-        code ^= frame->LookupDartCode();
-        if (!Append(frame->pc(), code)) {
-          return;
-        }
-        frame = frame_iterator_.NextFrame();
-      }
-    } else {
-      while (frame != NULL) {
-        if (!Append(frame->pc())) {
-          return;
-        }
-        frame = frame_iterator_.NextFrame();
-      }
-    }
-  }
-
- private:
-  DartFrameIterator frame_iterator_;
-};
-
-
 // Executing Dart code, walk the stack.
 class ProfilerDartStackWalker : public ProfilerStackWalker {
  public:
-  ProfilerDartStackWalker(Isolate* isolate,
+  ProfilerDartStackWalker(Thread* thread,
                           Sample* sample,
                           SampleBuffer* sample_buffer,
                           uword stack_lower,
                           uword stack_upper,
                           uword pc,
                           uword fp,
-                          uword sp)
-      : ProfilerStackWalker(isolate, sample, sample_buffer),
+                          uword sp,
+                          bool exited_dart_code,
+                          bool allocation_sample)
+      : ProfilerStackWalker(thread->isolate(), sample, sample_buffer),
+        pc_(reinterpret_cast<uword*>(pc)),
+        fp_(reinterpret_cast<uword*>(fp)),
+        sp_(reinterpret_cast<uword*>(sp)),
         stack_upper_(stack_upper),
-        stack_lower_(stack_lower) {
-    pc_ = reinterpret_cast<uword*>(pc);
-    fp_ = reinterpret_cast<uword*>(fp);
-    sp_ = reinterpret_cast<uword*>(sp);
+        stack_lower_(stack_lower),
+        has_exit_frame_(exited_dart_code) {
+    if (exited_dart_code) {
+      StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
+                                  thread);
+      pc_ = NULL;
+      fp_ = NULL;
+      sp_ = NULL;
+      if (!iterator.HasNextFrame()) {
+        return;
+      }
+      // Ensure we are able to get to the exit frame.
+      StackFrame* frame = iterator.NextFrame();
+      if (!frame->IsExitFrame()) {
+        return;
+      }
+      // Skip the exit frame.
+      if (!iterator.HasNextFrame()) {
+        return;
+      }
+      frame = iterator.NextFrame();
+      // Record frame details of the first frame from which we start walking.
+      pc_ = reinterpret_cast<uword*>(frame->pc());
+      fp_ = reinterpret_cast<uword*>(frame->fp());
+      sp_ = reinterpret_cast<uword*>(frame->sp());
+    }
   }
 
   void walk() {
-    sample_->set_exit_frame_sample(false);
+    sample_->set_exit_frame_sample(has_exit_frame_);
     if (!ValidFramePointer()) {
       sample_->set_ignore_sample(true);
       return;
     }
     ASSERT(ValidFramePointer());
     uword return_pc = InitialReturnAddress();
     if (StubCode::InInvocationStub(return_pc)) {
       // Edge case- we have called out from the Invocation Stub but have not
       // created the stack frame of the callee. Attempt to locate the exit
       // frame before walking the stack.
@@ skipping 106 matching lines @@
     }
     uword cursor = reinterpret_cast<uword>(fp);
     cursor += sizeof(fp);
     return (cursor >= stack_lower_) && (cursor < stack_upper_);
   }
 
   uword* pc_;
   uword* fp_;
   uword* sp_;
   const uword stack_upper_;
-  uword stack_lower_;
+  const uword stack_lower_;
+  bool has_exit_frame_;
 };
 
 
 // If the VM is compiled without frame pointers (which is the default on
 // recent GCC versions with optimizing enabled) the stack walking code may
 // fail.
 //
 class ProfilerNativeStackWalker : public ProfilerStackWalker {
  public:
   ProfilerNativeStackWalker(Isolate* isolate,
@@ skipping 132 matching lines @@
   return EXCEPTION_EXECUTE_HANDLER;
 }
 #endif
 
 // All memory access done to collect the sample is performed in CollectSample.
 static void CollectSample(Isolate* isolate,
                           bool exited_dart_code,
                           bool in_dart_code,
                           Sample* sample,
                           ProfilerNativeStackWalker* native_stack_walker,
-                          ProfilerDartExitStackWalker* dart_exit_stack_walker,
                           ProfilerDartStackWalker* dart_stack_walker,
                           uword pc,
                           uword fp,
                           uword sp,
                           ProfilerCounters* counters) {
   ASSERT(counters != NULL);
 #if defined(TARGET_OS_WINDOWS)
   // Use structured exception handling to trap guard page access on Windows.
   __try {
 #endif
 
     if (in_dart_code) {
       // We can only trust the stack pointer if we are executing Dart code.
       // See http://dartbug.com/20421 for details.
       CopyStackBuffer(sample, sp);
     }
 
     if (FLAG_profile_vm) {
       // Always walk the native stack collecting both native and Dart frames.
       AtomicOperations::IncrementInt64By(&counters->stack_walker_native, 1);
       native_stack_walker->walk();
     } else if (StubCode::HasBeenInitialized() && exited_dart_code) {
       AtomicOperations::IncrementInt64By(&counters->stack_walker_dart_exit, 1);
       // We have a valid exit frame info, use the Dart stack walker.
-      dart_exit_stack_walker->walk();
+      dart_stack_walker->walk();
     } else if (StubCode::HasBeenInitialized() && in_dart_code) {
       AtomicOperations::IncrementInt64By(&counters->stack_walker_dart, 1);
       // We are executing Dart code. We have frame pointers.
       dart_stack_walker->walk();
     } else {
       AtomicOperations::IncrementInt64By(&counters->stack_walker_none, 1);
       sample->SetAt(0, pc);
     }
 
 #if defined(TARGET_OS_WINDOWS)
@@ skipping 140 matching lines @@
   return reinterpret_cast<uintptr_t>(_ReturnAddress());
 }
 #else
 static uintptr_t __attribute__((noinline)) GetProgramCounter() {
   return reinterpret_cast<uintptr_t>(
       __builtin_extract_return_addr(__builtin_return_address(0)));
 }
 #endif
 
 
-void Profiler::DumpStackTrace(bool native_stack_trace) {
+void Profiler::DumpStackTrace() {
   // Allow only one stack trace to prevent recursively printing stack traces if
   // we hit an assert while printing the stack.
   static uintptr_t started_dump = 0;
   if (AtomicOperations::FetchAndIncrement(&started_dump) != 0) {
     OS::PrintErr("Aborting re-entrant request for stack trace.\n");
     return;
   }
 
   Thread* thread = Thread::Current();
   if (thread == NULL) {
     return;
   }
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
   if (!CheckIsolate(isolate)) {
     return;
   }
 
-  const bool exited_dart_code = thread->HasExitedDartCode();
-
-  OS::PrintErr("Dumping %s stack trace for thread %" Px "\n",
-               native_stack_trace ? "native" : "dart-only",
+  OS::PrintErr("Dumping native stack trace for thread %" Px "\n",
                OSThread::ThreadIdToIntPtr(os_thread->trace_id()));
 
   uintptr_t sp = Thread::GetCurrentStackPointer();
   uintptr_t fp = 0;
   uintptr_t pc = GetProgramCounter();
 
   COPY_FP_REGISTER(fp);
 
   uword stack_lower = 0;
   uword stack_upper = 0;
 
   if (!InitialRegisterCheck(pc, fp, sp)) {
     OS::PrintErr("Stack dump aborted because InitialRegisterCheck.\n");
     return;
   }
 
   if (!GetAndValidateIsolateStackBounds(thread, fp, sp, &stack_lower,
                                         &stack_upper)) {
     OS::PrintErr(
         "Stack dump aborted because GetAndValidateIsolateStackBounds.\n");
     return;
   }
 
-  if (native_stack_trace) {
-    ProfilerNativeStackWalker native_stack_walker(
-        isolate, NULL, NULL, stack_lower, stack_upper, pc, fp, sp);
-    native_stack_walker.walk();
-  } else if (exited_dart_code) {
-    ProfilerDartExitStackWalker dart_exit_stack_walker(thread, isolate, NULL,
-                                                       NULL);
-    dart_exit_stack_walker.walk();
-  } else {
-    ProfilerDartStackWalker dart_stack_walker(isolate, NULL, NULL, stack_lower,
-                                              stack_upper, pc, fp, sp);
-  }
+  ProfilerNativeStackWalker native_stack_walker(
+      isolate, NULL, NULL, stack_lower, stack_upper, pc, fp, sp);
+  native_stack_walker.walk();
   OS::PrintErr("-- End of DumpStackTrace\n");
 }
 
 
 void Profiler::SampleAllocation(Thread* thread, intptr_t cid) {
   ASSERT(thread != NULL);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
   if (!CheckIsolate(isolate)) {
     return;
   }
 
   const bool exited_dart_code = thread->HasExitedDartCode();
 
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     // Profiler not initialized.
     return;
   }
 
+  uintptr_t sp = Thread::GetCurrentStackPointer();
+  uintptr_t fp = 0;
+  uintptr_t pc = GetProgramCounter();
+
+  COPY_FP_REGISTER(fp);
+
+  uword stack_lower = 0;
+  uword stack_upper = 0;
+
+  if (!InitialRegisterCheck(pc, fp, sp)) {
+    return;
+  }
+
+  if (!GetAndValidateIsolateStackBounds(thread, fp, sp, &stack_lower,
+                                        &stack_upper)) {
+    // Could not get stack boundary.
+    return;
+  }
+
+  Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
+  sample->SetAllocationCid(cid);
+
   if (FLAG_profile_vm) {
-    uintptr_t sp = Thread::GetCurrentStackPointer();
-    uintptr_t fp = 0;
-    uintptr_t pc = GetProgramCounter();
-
-    COPY_FP_REGISTER(fp);
-
-    uword stack_lower = 0;
-    uword stack_upper = 0;
-
-    if (!InitialRegisterCheck(pc, fp, sp)) {
-      return;
-    }
-
-    if (!GetAndValidateIsolateStackBounds(thread, fp, sp, &stack_lower,
-                                          &stack_upper)) {
-      // Could not get stack boundary.
-      return;
-    }
-
-    Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
-    sample->SetAllocationCid(cid);
     ProfilerNativeStackWalker native_stack_walker(
         isolate, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp);
     native_stack_walker.walk();
   } else if (exited_dart_code) {
-    Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
-    sample->SetAllocationCid(cid);
-    ProfilerDartExitStackWalker dart_exit_stack_walker(thread, isolate, sample,
-                                                       sample_buffer);
+    ProfilerDartStackWalker dart_exit_stack_walker(
+        thread, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp,
+        exited_dart_code, true);
     dart_exit_stack_walker.walk();
   } else {
     // Fall back.
     uintptr_t pc = GetProgramCounter();
     Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
     sample->SetAllocationCid(cid);
     sample->SetAt(0, pc);
   }
 }
 
@@ skipping 118 matching lines @@
   Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   if (thread->IsMutatorThread()) {
     counters->Increment(sample->vm_tag());
   }
 
   ProfilerNativeStackWalker native_stack_walker(
       isolate, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp);
-
-  ProfilerDartExitStackWalker dart_exit_stack_walker(thread, isolate, sample,
-                                                     sample_buffer);
-
-  ProfilerDartStackWalker dart_stack_walker(
-      isolate, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp);
-
   const bool exited_dart_code = thread->HasExitedDartCode();
+  ProfilerDartStackWalker dart_stack_walker(thread, sample, sample_buffer,
+                                            stack_lower, stack_upper, pc, fp,
+                                            sp, exited_dart_code, false);
 
   // All memory access is done inside CollectSample.
   CollectSample(isolate, exited_dart_code, in_dart_code, sample,
-                &native_stack_walker, &dart_exit_stack_walker,
-                &dart_stack_walker, pc, fp, sp, &counters_);
+                &native_stack_walker, &dart_stack_walker, pc, fp, sp,
+                &counters_);
 }
 
 
 CodeDescriptor::CodeDescriptor(const Code& code) : code_(code) {
   ASSERT(!code_.IsNull());
 }
 
 
 uword CodeDescriptor::Start() const {
   return code_.PayloadStart();
@@ skipping 311 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart