[Isolates] Merge crankshaft (r5922 from bleeding_edge).

src/cpu-profiler.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 16 matching lines @@
 
 #include "v8.h"
 
 #include "cpu-profiler-inl.h"
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 #include "frames-inl.h"
 #include "hashmap.h"
 #include "log-inl.h"
+#include "vm-state-inl.h"
 
 #include "../include/v8-profiler.h"
 
 namespace v8 {
 namespace internal {
 
 static const int kEventsBufferSize = 256*KB;
 static const int kTickSamplesBufferChunkSize = 64*KB;
 static const int kTickSamplesBufferChunksCount = 16;
 
@@ skipping 171 matching lines @@
   rec->start = start;
   rec->entry = generator_->NewCodeEntry(tag, prefix, name);
   rec->size = size;
   events_buffer_.Enqueue(evt_rec);
 }
 
 
 void ProfilerEventsProcessor::AddCurrentStack() {
   TickSampleEventRecord record;
   TickSample* sample = &record.sample;
-  sample->state = VMState::current_state();
+  sample->state = Isolate::Current()->current_vm_state();
   sample->pc = reinterpret_cast<Address>(sample);  // Not NULL.
   sample->frames_count = 0;
   for (StackTraceFrameIterator it;
        !it.done() && sample->frames_count < TickSample::kMaxFramesCount;
        it.Advance()) {
     JavaScriptFrame* frame = it.frame();
     sample->stack[sample->frames_count++] =
         reinterpret_cast<Address>(frame->function());
   }
   record.order = enqueue_order_;
@@ skipping 118 matching lines @@
 
 
 CpuProfile* CpuProfiler::FindProfile(Object* security_token, unsigned uid) {
   ASSERT(Isolate::Current()->cpu_profiler() != NULL);
   CpuProfiler* profiler = Isolate::Current()->cpu_profiler();
   const int token = profiler->token_enumerator_->GetTokenId(security_token);
   return profiler->profiles_->GetProfile(token, uid);
 }
 
 
-TickSample* CpuProfiler::TickSampleEvent() {
-  if (CpuProfiler::is_profiling()) {
-    return Isolate::Current()->cpu_profiler()->processor_->TickSampleEvent();
+TickSample* CpuProfiler::TickSampleEvent(Isolate* isolate) {
+  if (CpuProfiler::is_profiling(isolate)) {
+    return isolate->cpu_profiler()->processor_->TickSampleEvent();
   } else {
     return NULL;
   }
 }
 
 
 void CpuProfiler::CallbackEvent(String* name, Address entry_point) {
   Isolate::Current()->cpu_profiler()->processor_->CallbackCreateEvent(
       Logger::CALLBACK_TAG, CodeEntry::kEmptyNamePrefix, name, entry_point);
 }
@@ skipping 53 matching lines @@
 
 void CpuProfiler::FunctionCreateEvent(JSFunction* function) {
   CpuProfiler* profiler = Isolate::Current()->cpu_profiler();
   int security_token_id = TokenEnumerator::kNoSecurityToken;
   if (function->unchecked_context()->IsContext()) {
     security_token_id = profiler->token_enumerator_->GetTokenId(
         function->context()->global_context()->security_token());
   }
   profiler->processor_->FunctionCreateEvent(
       function->address(),
-      function->code()->address(),
+      function->shared()->code()->address(),
       security_token_id);
 }
 
 
 void CpuProfiler::ProcessMovedFunctions() {
   CpuProfiler* profiler = Isolate::Current()->cpu_profiler();
   profiler->processor_->ProcessMovedFunctions();
 }
 
 
@@ skipping 45 matching lines @@
   Isolate::Current()->cpu_profiler()->processor_->CallbackCreateEvent(
       Logger::CALLBACK_TAG, "set ", name, entry_point);
 }
 
 
 CpuProfiler::CpuProfiler()
     : profiles_(new CpuProfilesCollection()),
       next_profile_uid_(1),
       token_enumerator_(new TokenEnumerator()),
       generator_(NULL),
-      processor_(NULL) {
+      processor_(NULL),
+      is_profiling_(false) {
 }
 
 
 CpuProfiler::~CpuProfiler() {
   delete token_enumerator_;
   delete profiles_;
 }
 
 
 void CpuProfiler::StartCollectingProfile(const char* title) {
   if (profiles_->StartProfiling(title, next_profile_uid_++)) {
     StartProcessorIfNotStarted();
   }
   processor_->AddCurrentStack();
 }
 
 
 void CpuProfiler::StartCollectingProfile(String* title) {
   StartCollectingProfile(profiles_->GetName(title));
 }
 
 
 void CpuProfiler::StartProcessorIfNotStarted() {
   if (processor_ == NULL) {
     // Disable logging when using the new implementation.
     saved_logging_nesting_ = LOGGER->logging_nesting_;
     LOGGER->logging_nesting_ = 0;
     generator_ = new ProfileGenerator(profiles_);
     processor_ = new ProfilerEventsProcessor(Isolate::Current(), generator_);
+    NoBarrier_Store(&is_profiling_, true);
     processor_->Start();
     // Enumerate stuff we already have in the heap.
     if (HEAP->HasBeenSetup()) {
       if (!FLAG_prof_browser_mode) {
         bool saved_log_code_flag = FLAG_log_code;
         FLAG_log_code = true;
         LOGGER->LogCodeObjects();
         FLAG_log_code = saved_log_code_flag;
       }
       LOGGER->LogCompiledFunctions();
       LOGGER->LogFunctionObjects();
       LOGGER->LogAccessorCallbacks();
     }
     // Enable stack sampling.
-    reinterpret_cast<Sampler*>(LOGGER->ticker_)->Start();
+    Sampler* sampler = reinterpret_cast<Sampler*>(LOGGER->ticker_);
+    if (!sampler->IsActive()) sampler->Start();
+    sampler->IncreaseProfilingDepth();
   }
 }
 
 
 CpuProfile* CpuProfiler::StopCollectingProfile(const char* title) {
   const double actual_sampling_rate = generator_->actual_sampling_rate();
   StopProcessorIfLastProfile(title);
   CpuProfile* result =
       profiles_->StopProfiling(TokenEnumerator::kNoSecurityToken,
                                title,
@@ skipping 10 matching lines @@
   const double actual_sampling_rate = generator_->actual_sampling_rate();
   const char* profile_title = profiles_->GetName(title);
   StopProcessorIfLastProfile(profile_title);
   int token = token_enumerator_->GetTokenId(security_token);
   return profiles_->StopProfiling(token, profile_title, actual_sampling_rate);
 }
 
 
 void CpuProfiler::StopProcessorIfLastProfile(const char* title) {
   if (profiles_->IsLastProfile(title)) {
-    reinterpret_cast<Sampler*>(LOGGER->ticker_)->Stop();
+    Sampler* sampler = reinterpret_cast<Sampler*>(LOGGER->ticker_);
+    sampler->DecreaseProfilingDepth();
+    sampler->Stop();
     processor_->Stop();
     processor_->Join();
     delete processor_;
     delete generator_;
     processor_ = NULL;
+    NoBarrier_Store(&is_profiling_, false);
     generator_ = NULL;
     LOGGER->logging_nesting_ = saved_logging_nesting_;
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 namespace v8 {
@@ skipping 13 matching lines @@
 #ifdef ENABLE_LOGGING_AND_PROFILING
   Isolate* isolate = Isolate::Current();
   if (isolate->cpu_profiler() != NULL) {
     delete isolate->cpu_profiler();
   }
   isolate->set_cpu_profiler(NULL);
 #endif
 }
 
 } }  // namespace v8::internal