[Isolates] Merge crankshaft (r5922 from bleeding_edge).

src/api.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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "api.h"
 
 #include "arguments.h"
 #include "bootstrapper.h"
 #include "compiler.h"
 #include "debug.h"
+#include "deoptimizer.h"
 #include "execution.h"
 #include "global-handles.h"
 #include "heap-profiler.h"
 #include "messages.h"
 #include "parser.h"
 #include "platform.h"
 #include "profile-generator-inl.h"
+#include "runtime-profiler.h"
 #include "serialize.h"
 #include "snapshot.h"
 #include "v8threads.h"
 #include "version.h"
+#include "vm-state-inl.h"
 
 #include "../include/v8-profiler.h"
+#include "../include/v8-testing.h"
 
 #define LOG_API(expr) LOG(ApiEntryCall(expr))
 
 // TODO(isolates): avoid repeated TLS reads in function prologues.
 #ifdef ENABLE_VMSTATE_TRACKING
-#define ENTER_V8 i::VMState __state__(i::Isolate::Current(), i::OTHER)
-#define LEAVE_V8 i::VMState __state__(i::Isolate::Current(), i::EXTERNAL)
+#define ENTER_V8                                        \
+  ASSERT(i::Isolate::Current()->IsInitialized());                           \
+  i::VMState __state__(i::Isolate::Current(), i::OTHER)
+#define LEAVE_V8 \
+  i::VMState __state__(i::Isolate::Current(), i::EXTERNAL)
 #else
 #define ENTER_V8 ((void) 0)
 #define LEAVE_V8 ((void) 0)
 #endif
 
 namespace v8 {
 
 #define ON_BAILOUT(location, code)                                 \
   if (IsDeadCheck(location) || v8::V8::IsExecutionTerminating()) { \
     code;                                                          \
@@ skipping 34 matching lines @@
                   IsLockedByCurrentThread(),                                   \
                msg,                                                            \
                "Entering the V8 API without proper locking in place");         \
     }                                                                          \
   } while (false)
 
 
 // --- E x c e p t i o n   B e h a v i o r ---
 
 
-
 static void DefaultFatalErrorHandler(const char* location,
                                      const char* message) {
   ENTER_V8;
   API_Fatal(location, message);
 }
 
 
 static FatalErrorCallback GetFatalErrorHandler() {
   i::Isolate* isolate = i::Isolate::Current();
   if (isolate->exception_behavior() == NULL) {
@@ skipping 120 matching lines @@
  * entry to all methods that touch anything in the heap, except destructors
  * which you sometimes can't avoid calling after the vm has crashed.  Functions
  * that call EnsureInitialized or ON_BAILOUT don't have to also call
  * IsDeadCheck.  ON_BAILOUT has the advantage over EnsureInitialized that you
  * can arrange to return if the VM is dead.  This is needed to ensure that no VM
  * heap allocations are attempted on a dead VM.  EnsureInitialized has the
  * advantage over ON_BAILOUT that it actually initializes the VM if this has not
  * yet been done.
  */
 static inline bool IsDeadCheck(const char* location) {
-  return !i::V8::IsRunning()
+  return !i::Isolate::Current()->IsInitialized()
       && i::V8::IsDead() ? ReportV8Dead(location) : false;
 }
 
 
 static inline bool EmptyCheck(const char* location, v8::Handle<v8::Data> obj) {
   return obj.IsEmpty() ? ReportEmptyHandle(location) : false;
 }
 
 
 static inline bool EmptyCheck(const char* location, const v8::Data* obj) {
   return (obj == 0) ? ReportEmptyHandle(location) : false;
 }
 
 // --- S t a t i c s ---
 
 
 static bool InitializeHelper() {
   if (i::Snapshot::Initialize()) return true;
   return i::V8::Initialize(NULL);
 }
 
 
 static inline bool EnsureInitializedForIsolate(i::Isolate* isolate,
                                                const char* location) {
+  if (IsDeadCheck(location)) return false;
   if (isolate != NULL) {
-    if (isolate->IsDefaultIsolate()) {
-      if (i::V8::IsRunning()) {
-        return true;
-      }
-      if (IsDeadCheck(location)) {
-        return false;
-      }
-    } else {
-      if (isolate->IsInitialized()) {
-        return true;
-      }
-    }
+    if (isolate->IsInitialized()) return true;
   }
   return ApiCheck(InitializeHelper(), location, "Error initializing V8");
 }
 
 static inline bool EnsureInitialized(const char* location) {
   i::Isolate* isolate = i::Isolate::UncheckedCurrent();
   return EnsureInitializedForIsolate(isolate, location);
 }
 
 #ifdef DEBUG
@@ skipping 154 matching lines @@
 
 
 void V8::ClearWeak(i::Object** obj) {
   LOG_API("ClearWeak");
   i::Isolate::Current()->global_handles()->ClearWeakness(obj);
 }
 
 
 bool V8::IsGlobalNearDeath(i::Object** obj) {
   LOG_API("IsGlobalNearDeath");
-  if (!i::V8::IsRunning()) return false;
+  if (!i::Isolate::Current()->IsInitialized()) return false;
   return i::GlobalHandles::IsNearDeath(obj);
 }
 
 
 bool V8::IsGlobalWeak(i::Object** obj) {
   LOG_API("IsGlobalWeak");
-  if (!i::V8::IsRunning()) return false;
+  if (!i::Isolate::Current()->IsInitialized()) return false;
   return i::GlobalHandles::IsWeak(obj);
 }
 
 
 void V8::DisposeGlobal(i::Object** obj) {
   LOG_API("DisposeGlobal");
-  if (!i::V8::IsRunning()) return;
+  if (!i::Isolate::Current()->IsInitialized()) return;
   i::Isolate::Current()->global_handles()->Destroy(obj);
 }
 
 // --- H a n d l e s ---
 
 
 HandleScope::HandleScope() {
   API_ENTRY_CHECK("HandleScope::HandleScope");
   i::Isolate* isolate = i::Isolate::Current();
   v8::ImplementationUtilities::HandleScopeData* current =
@@ skipping 56 matching lines @@
   // TODO(isolates): Context should have a pointer to isolate.
   i::Isolate* isolate = i::Isolate::Current();
   isolate->handle_scope_implementer()->EnterContext(env);
 
   isolate->handle_scope_implementer()->SaveContext(isolate->context());
   isolate->set_context(*env);
 }
 
 
 void Context::Exit() {
-  if (!i::V8::IsRunning()) return;
+  if (!i::Isolate::Current()->IsInitialized()) return;
   // TODO(isolates): Context should have a pointer to isolate.
   i::Isolate* isolate = i::Isolate::Current();
 
   if (!ApiCheck(isolate->handle_scope_implementer()->LeaveLastContext(),
                 "v8::Context::Exit()",
                 "Cannot exit non-entered context")) {
     return;
   }
 
   // Content of 'last_context' could be NULL.
@@ skipping 1780 matching lines @@
   return true;
 }
 
 
 bool v8::Object::ForceDelete(v8::Handle<Value> key) {
   ON_BAILOUT("v8::Object::ForceDelete()", return false);
   ENTER_V8;
   HandleScope scope;
   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
   i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
+
+  // When turning on access checks for a global object deoptimize all functions
+  // as optimized code does not always handle access checks.
+  i::Deoptimizer::DeoptimizeGlobalObject(*self);
+
   EXCEPTION_PREAMBLE();
   i::Handle<i::Object> obj = i::ForceDeleteProperty(self, key_obj);
   has_pending_exception = obj.is_null();
   EXCEPTION_BAILOUT_CHECK(false);
   return obj->IsTrue();
 }
 
 
 Local<Value> v8::Object::Get(v8::Handle<Value> key) {
   ON_BAILOUT("v8::Object::Get()", return Local<v8::Value>());
@@ skipping 266 matching lines @@
 
 // Turns on access checks by copying the map and setting the check flag.
 // Because the object gets a new map, existing inline cache caching
 // the old map of this object will fail.
 void v8::Object::TurnOnAccessCheck() {
   ON_BAILOUT("v8::Object::TurnOnAccessCheck()", return);
   ENTER_V8;
   HandleScope scope;
   i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
 
+  // When turning on access checks for a global object deoptimize all functions
+  // as optimized code does not always handle access checks.
+  i::Deoptimizer::DeoptimizeGlobalObject(*obj);
+
   i::Handle<i::Map> new_map =
     FACTORY->CopyMapDropTransitions(i::Handle<i::Map>(obj->map()));
   new_map->set_is_access_check_needed(true);
   obj->set_map(*new_map);
 }
 
 
 bool v8::Object::IsDirty() {
   return Utils::OpenHandle(this)->IsDirty();
 }
@@ skipping 583 matching lines @@
   if (!proxy.is_null())
       Utils::OpenHandle(this)->SetInternalField(index, *proxy);
 }
 
 
 // --- E n v i r o n m e n t ---
 
 
 bool v8::V8::Initialize() {
   i::Isolate* isolate = i::Isolate::UncheckedCurrent();
-  if (isolate != NULL && isolate->IsDefaultIsolate() && i::V8::IsRunning()) {
+  if (isolate != NULL && isolate->IsInitialized()) {
     return true;
   }
-  ENTER_V8;
   return InitializeHelper();
 }
 
 
 bool v8::V8::Dispose() {
   i::Isolate* isolate = i::Isolate::Current();
   if (!ApiCheck(isolate != NULL && isolate->IsDefaultIsolate(),
                 "v8::V8::Dispose()",
                 "Use v8::Isolate::Dispose() for a non-default isolate.")) {
     return false;
@@ skipping 12 matching lines @@
   heap_statistics->set_total_heap_size(HEAP->CommittedMemory());
   heap_statistics->set_total_heap_size_executable(
       HEAP->CommittedMemoryExecutable());
   heap_statistics->set_used_heap_size(HEAP->SizeOfObjects());
 }
 
 
 bool v8::V8::IdleNotification() {
   // Returning true tells the caller that it need not
   // continue to call IdleNotification.
-  if (!i::V8::IsRunning()) return true;
+  if (!i::Isolate::Current()->IsInitialized()) return true;
   return i::V8::IdleNotification();
 }
 
 
 void v8::V8::LowMemoryNotification() {
-  if (!i::V8::IsRunning()) return;
+  if (!i::Isolate::Current()->IsInitialized()) return;
   HEAP->CollectAllGarbage(true);
 }
 
 
 int v8::V8::ContextDisposedNotification() {
-  if (!i::V8::IsRunning()) return 0;
+  if (!i::Isolate::Current()->IsInitialized()) return 0;
   return HEAP->NotifyContextDisposed();
 }
 
 
 const char* v8::V8::GetVersion() {
   return i::Version::GetVersion();
 }
 
 
 static i::Handle<i::FunctionTemplateInfo>
@@ skipping 60 matching lines @@
 
     // Restore the access check info on the global template.
     if (!global_template.IsEmpty()) {
       ASSERT(!global_constructor.is_null());
       ASSERT(!proxy_constructor.is_null());
       global_constructor->set_access_check_info(
           proxy_constructor->access_check_info());
       global_constructor->set_needs_access_check(
           proxy_constructor->needs_access_check());
     }
+    i::Isolate::Current()->runtime_profiler()->Reset();
   }
   // Leave V8.
 
   if (env.is_null())
     return Persistent<Context>();
   return Persistent<Context>(Utils::ToLocal(env));
 }
 
 
 void v8::Context::SetSecurityToken(Handle<Value> token) {
@@ skipping 747 matching lines @@
 
 
 int V8::GetCurrentThreadId() {
   API_ENTRY_CHECK("V8::GetCurrentThreadId()");
   EnsureInitialized("V8::GetCurrentThreadId()");
   return i::Isolate::Current()->thread_id();
 }
 
 
 void V8::TerminateExecution(int thread_id) {
-  if (!i::V8::IsRunning()) return;
+  if (!i::Isolate::Current()->IsInitialized()) return;
   API_ENTRY_CHECK("V8::GetCurrentThreadId()");
   i::Isolate* isolate = i::Isolate::Current();
   // If the thread_id identifies the current thread just terminate
   // execution right away.  Otherwise, ask the thread manager to
   // terminate the thread with the given id if any.
   if (thread_id == isolate->thread_id()) {
     isolate->stack_guard()->TerminateExecution();
   } else {
     isolate->thread_manager()->TerminateExecution(thread_id);
   }
 }
 
 
 void V8::TerminateExecution() {
-  if (!i::V8::IsRunning()) return;
+  if (!i::Isolate::Current()->IsInitialized()) return;
   i::Isolate::Current()->stack_guard()->TerminateExecution();
 }
 
 
 bool V8::IsExecutionTerminating() {
-  if (!i::V8::IsRunning()) return false;
+  if (!i::Isolate::Current()->IsInitialized()) return false;
   if (i::Isolate::Current()->has_scheduled_exception()) {
     return i::Isolate::Current()->scheduled_exception() ==
         HEAP->termination_exception();
   }
   return false;
 }
 
 
 Isolate* Isolate::GetCurrent() {
   i::Isolate* isolate = i::Isolate::UncheckedCurrent();
@@ skipping 240 matching lines @@
                                   Handle<Value> data) {
   ON_BAILOUT("v8::Debug::SetDebugEventListener()", return false);
   ENTER_V8;
   i::Isolate::Current()->debugger()->SetEventListener(Utils::OpenHandle(*that),
                                                       Utils::OpenHandle(*data));
   return true;
 }
 
 
 void Debug::DebugBreak() {
-  if (!i::V8::IsRunning()) return;
+  if (!i::Isolate::Current()->IsInitialized()) return;
   i::Isolate::Current()->stack_guard()->DebugBreak();
 }
 
 
 void Debug::CancelDebugBreak() {
   i::Isolate::Current()->stack_guard()->Continue(i::DEBUGBREAK);
 }
 
 
 void Debug::DebugBreakForCommand(ClientData* data) {
-  if (!i::V8::IsRunning()) return;
+  if (!i::Isolate::Current()->IsInitialized()) return;
   i::Isolate::Current()->debugger()->EnqueueDebugCommand(data);
 }
 
 
 static void MessageHandlerWrapper(const v8::Debug::Message& message) {
   i::Isolate* isolate = i::Isolate::Current();
   if (isolate->message_handler()) {
     v8::String::Value json(message.GetJSON());
     (isolate->message_handler())(*json, json.length(), message.GetClientData());
   }
@@ skipping 21 matching lines @@
 
 void Debug::SetMessageHandler2(v8::Debug::MessageHandler2 handler) {
   EnsureInitialized("v8::Debug::SetMessageHandler");
   ENTER_V8;
   i::Isolate::Current()->debugger()->SetMessageHandler(handler);
 }
 
 
 void Debug::SendCommand(const uint16_t* command, int length,
                         ClientData* client_data) {
-  if (!i::V8::IsRunning()) return;
+  if (!i::Isolate::Current()->IsInitialized()) return;
   i::Isolate::Current()->debugger()->ProcessCommand(
       i::Vector<const uint16_t>(command, length), client_data);
 }
 
 
 void Debug::SetHostDispatchHandler(HostDispatchHandler handler,
                                    int period) {
   EnsureInitialized("v8::Debug::SetHostDispatchHandler");
   ENTER_V8;
   i::Isolate::Current()->debugger()->SetHostDispatchHandler(handler, period);
 }
 
 
 void Debug::SetDebugMessageDispatchHandler(
     DebugMessageDispatchHandler handler, bool provide_locker) {
   EnsureInitialized("v8::Debug::SetDebugMessageDispatchHandler");
   ENTER_V8;
   i::Isolate::Current()->debugger()->SetDebugMessageDispatchHandler(
       handler, provide_locker);
 }
 
 
 Local<Value> Debug::Call(v8::Handle<v8::Function> fun,
                          v8::Handle<v8::Value> data) {
-  if (!i::V8::IsRunning()) return Local<Value>();
+  if (!i::Isolate::Current()->IsInitialized()) return Local<Value>();
   ON_BAILOUT("v8::Debug::Call()", return Local<Value>());
   ENTER_V8;
   i::Handle<i::Object> result;
   EXCEPTION_PREAMBLE();
   if (data.IsEmpty()) {
     result =
         i::Isolate::Current()->debugger()->Call(Utils::OpenHandle(*fun),
                                                 FACTORY->undefined_value(),
                                                 &has_pending_exception);
   } else {
     result = i::Isolate::Current()->debugger()->Call(Utils::OpenHandle(*fun),
                                                      Utils::OpenHandle(*data),
                                                      &has_pending_exception);
   }
   EXCEPTION_BAILOUT_CHECK(Local<Value>());
   return Utils::ToLocal(result);
 }
 
 
 Local<Value> Debug::GetMirror(v8::Handle<v8::Value> obj) {
-  if (!i::V8::IsRunning()) return Local<Value>();
+  if (!i::Isolate::Current()->IsInitialized()) return Local<Value>();
   ON_BAILOUT("v8::Debug::GetMirror()", return Local<Value>());
   ENTER_V8;
   v8::HandleScope scope;
   i::Debug* isolate_debug = i::Isolate::Current()->debug();
   isolate_debug->Load();
   i::Handle<i::JSObject> debug(isolate_debug->debug_context()->global());
   i::Handle<i::String> name = FACTORY->LookupAsciiSymbol("MakeMirror");
   i::Handle<i::Object> fun_obj = i::GetProperty(debug, name);
   i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(fun_obj);
   v8::Handle<v8::Function> v8_fun = Utils::ToLocal(fun);
@@ skipping 450 matching lines @@
     default:
       UNREACHABLE();
   }
   return reinterpret_cast<const HeapSnapshot*>(
       i::HeapProfiler::TakeSnapshot(*Utils::OpenHandle(*title), internal_type));
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 
+v8::Testing::StressType internal::Testing::stress_type_ =
+    v8::Testing::kStressTypeOpt;
+
+
+void Testing::SetStressRunType(Testing::StressType type) {
+  internal::Testing::set_stress_type(type);
+}
+
+int Testing::GetStressRuns() {
+#ifdef DEBUG
+  // In debug mode the code runs much slower so stressing will only make two
+  // runs.
+  return 2;
+#else
+  return 5;
+#endif
+}
+
+
+static void SetFlagsFromString(const char* flags) {
+  V8::SetFlagsFromString(flags, i::StrLength(flags));
+}
+
+
+void Testing::PrepareStressRun(int run) {
+  static const char* kLazyOptimizations =
+      "--prepare-always-opt --nolimit-inlining "
+      "--noalways-opt --noopt-eagerly";
+  static const char* kEagerOptimizations = "--opt-eagerly";
+  static const char* kForcedOptimizations = "--always-opt";
+
+  // If deoptimization stressed turn on frequent deoptimization. If no value
+  // is spefified through --deopt-every-n-times use a default default value.
+  static const char* kDeoptEvery13Times = "--deopt-every-n-times=13";
+  if (internal::Testing::stress_type() == Testing::kStressTypeDeopt &&
+      internal::FLAG_deopt_every_n_times == 0) {
+    SetFlagsFromString(kDeoptEvery13Times);
+  }
+
+#ifdef DEBUG
+  // As stressing in debug mode only make two runs skip the deopt stressing
+  // here.
+  if (run == GetStressRuns() - 1) {
+    SetFlagsFromString(kForcedOptimizations);
+  } else {
+    SetFlagsFromString(kEagerOptimizations);
+    SetFlagsFromString(kLazyOptimizations);
+  }
+#else
+  if (run == GetStressRuns() - 1) {
+    SetFlagsFromString(kForcedOptimizations);
+  } else if (run == GetStressRuns() - 2) {
+    SetFlagsFromString(kEagerOptimizations);
+  } else {
+    SetFlagsFromString(kLazyOptimizations);
+  }
+#endif
+}
+
+
 namespace internal {
 
 
 void HandleScopeImplementer::FreeThreadResources() {
   Free();
 }
 
 
 char* HandleScopeImplementer::ArchiveThread(char* storage) {
   Isolate* isolate = Isolate::Current();
@@ skipping 49 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal