[Isolates] Move contents of Top into Isolate....

src/execution.cc

 // Copyright 2006-2008 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 107 matching lines @@
     value = CALL_GENERATED_CODE(entry, entry_address, function,
                                 receiver_pointer, argc, args);
   }
 
 #ifdef DEBUG
   value->Verify();
 #endif
 
   // Update the pending exception flag and return the value.
   *has_pending_exception = value->IsException();
-  ASSERT(*has_pending_exception == Top::has_pending_exception());
+  ASSERT(*has_pending_exception == Isolate::Current()->has_pending_exception());
   if (*has_pending_exception) {
-    Top::ReportPendingMessages();
+    Isolate::Current()->ReportPendingMessages();
     return Handle<Object>();
   } else {
-    Top::clear_pending_message();
+    Isolate::Current()->clear_pending_message();
   }
 
   return Handle<Object>(value);
 }
 
 
 Handle<Object> Execution::Call(Handle<JSFunction> func,
                                Handle<Object> receiver,
                                int argc,
                                Object*** args,
                                bool* pending_exception) {
   return Invoke(false, func, receiver, argc, args, pending_exception);
 }
 
 
 Handle<Object> Execution::New(Handle<JSFunction> func, int argc,
                               Object*** args, bool* pending_exception) {
-  return Invoke(true, func, Top::global(), argc, args, pending_exception);
+  return Invoke(true, func, Isolate::Current()->global(), argc, args,
+                pending_exception);
 }
 
 
 Handle<Object> Execution::TryCall(Handle<JSFunction> func,
                                   Handle<Object> receiver,
                                   int argc,
                                   Object*** args,
                                   bool* caught_exception) {
   // Enter a try-block while executing the JavaScript code. To avoid
   // duplicate error printing it must be non-verbose.  Also, to avoid
   // creating message objects during stack overflow we shouldn't
   // capture messages.
   v8::TryCatch catcher;
   catcher.SetVerbose(false);
   catcher.SetCaptureMessage(false);
 
   Handle<Object> result = Invoke(false, func, receiver, argc, args,
                                  caught_exception);
 
   if (*caught_exception) {
     ASSERT(catcher.HasCaught());
-    ASSERT(Top::has_pending_exception());
-    ASSERT(Top::external_caught_exception());
-    if (Top::pending_exception() == HEAP->termination_exception()) {
+    ASSERT(Isolate::Current()->has_pending_exception());
+    ASSERT(Isolate::Current()->external_caught_exception());
+    if (Isolate::Current()->pending_exception() ==
+        HEAP->termination_exception()) {
       result = Factory::termination_exception();
     } else {
       result = v8::Utils::OpenHandle(*catcher.Exception());
     }
-    Top::OptionalRescheduleException(true);
+    Isolate::Current()->OptionalRescheduleException(true);
   }
 
-  ASSERT(!Top::has_pending_exception());
-  ASSERT(!Top::external_caught_exception());
+  ASSERT(!Isolate::Current()->has_pending_exception());
+  ASSERT(!Isolate::Current()->external_caught_exception());
   return result;
 }
 
 
 Handle<Object> Execution::GetFunctionDelegate(Handle<Object> object) {
   ASSERT(!object->IsJSFunction());
 
   // If you return a function from here, it will be called when an
   // attempt is made to call the given object as a function.
 
   // Regular expressions can be called as functions in both Firefox
   // and Safari so we allow it too.
   if (object->IsJSRegExp()) {
     Handle<String> exec = Factory::exec_symbol();
     return Handle<Object>(object->GetProperty(*exec));
   }
 
   // Objects created through the API can have an instance-call handler
   // that should be used when calling the object as a function.
   if (object->IsHeapObject() &&
       HeapObject::cast(*object)->map()->has_instance_call_handler()) {
     return Handle<JSFunction>(
-        Top::global_context()->call_as_function_delegate());
+        Isolate::Current()->global_context()->call_as_function_delegate());
   }
 
   return Factory::undefined_value();
 }
 
 
 Handle<Object> Execution::GetConstructorDelegate(Handle<Object> object) {
   ASSERT(!object->IsJSFunction());
 
   // If you return a function from here, it will be called when an
   // attempt is made to call the given object as a constructor.
 
   // Objects created through the API can have an instance-call handler
   // that should be used when calling the object as a function.
   if (object->IsHeapObject() &&
       HeapObject::cast(*object)->map()->has_instance_call_handler()) {
     return Handle<JSFunction>(
-        Top::global_context()->call_as_constructor_delegate());
+        Isolate::Current()->global_context()->call_as_constructor_delegate());
   }
 
   return Factory::undefined_value();
 }
 
 
 bool StackGuard::IsStackOverflow() {
   ExecutionAccess access;
   return (thread_local_.jslimit_ != kInterruptLimit &&
           thread_local_.climit_ != kInterruptLimit);
@@ skipping 111 matching lines @@
   ExecutionAccess access;
   memcpy(to, reinterpret_cast<char*>(&thread_local_), sizeof(ThreadLocal));
   ThreadLocal blank;
 
   // Set the stack limits using the old thread_local_.
   // TODO(isolates): This was the old semantics of constructing a ThreadLocal
   //                 (as the ctor called SetStackLimits, which looked at the
   //                 current thread_local_ from StackGuard)-- but is this
   //                 really what was intended?
   isolate_->heap()->SetStackLimits();
+  thread_local_ = blank;
 
-  thread_local_ = blank;
   return to + sizeof(ThreadLocal);
 }
 
 
 char* StackGuard::RestoreStackGuard(char* from) {
   ExecutionAccess access;
   memcpy(reinterpret_cast<char*>(&thread_local_), from, sizeof(ThreadLocal));
   isolate_->heap()->SetStackLimits();
   return from + sizeof(ThreadLocal);
 }
@@ skipping 52 matching lines @@
   void* stored_limit = Thread::GetThreadLocal(stack_limit_key);
   // You should hold the ExecutionAccess lock when you call this.
   if (stored_limit != NULL) {
     StackGuard::SetStackLimit(reinterpret_cast<intptr_t>(stored_limit));
   }
 }
 
 
 // --- C a l l s   t o   n a t i v e s ---
 
-#define RETURN_NATIVE_CALL(name, argc, argv, has_pending_exception) \
-  do {                                                              \
-    Object** args[argc] = argv;                                     \
-    ASSERT(has_pending_exception != NULL);                          \
-    return Call(Top::name##_fun(), Top::builtins(), argc, args,     \
-                has_pending_exception);                             \
+#define RETURN_NATIVE_CALL(name, argc, argv, has_pending_exception)            \
+  do {                                                                         \
+    Object** args[argc] = argv;                                                \
+    ASSERT(has_pending_exception != NULL);                                     \
+    return Call(Isolate::Current()->name##_fun(),                              \
+                Isolate::Current()->builtins(), argc, args,                    \
+                has_pending_exception);                                        \
   } while (false)
 
 
 Handle<Object> Execution::ToBoolean(Handle<Object> obj) {
   // See the similar code in runtime.js:ToBoolean.
   if (obj->IsBoolean()) return obj;
   bool result = true;
   if (obj->IsString()) {
     result = Handle<String>::cast(obj)->length() != 0;
   } else if (obj->IsNull() || obj->IsUndefined()) {
@@ skipping 51 matching lines @@
 #undef RETURN_NATIVE_CALL
 
 
 Handle<Object> Execution::CharAt(Handle<String> string, uint32_t index) {
   int int_index = static_cast<int>(index);
   if (int_index < 0 || int_index >= string->length()) {
     return Factory::undefined_value();
   }
 
   Handle<Object> char_at =
-      GetProperty(Top::builtins(), Factory::char_at_symbol());
+      GetProperty(Isolate::Current()->builtins(), Factory::char_at_symbol());
   if (!char_at->IsJSFunction()) {
     return Factory::undefined_value();
   }
 
   bool caught_exception;
   Handle<Object> index_object = Factory::NewNumberFromInt(int_index);
   Object** index_arg[] = { index_object.location() };
   Handle<Object> result = TryCall(Handle<JSFunction>::cast(char_at),
                                   string,
                                   ARRAY_SIZE(index_arg),
                                   index_arg,
                                   &caught_exception);
   if (caught_exception) {
     return Factory::undefined_value();
   }
   return result;
 }
 
 
 Handle<JSFunction> Execution::InstantiateFunction(
     Handle<FunctionTemplateInfo> data, bool* exc) {
   // Fast case: see if the function has already been instantiated
   int serial_number = Smi::cast(data->serial_number())->value();
   Object* elm =
-      Top::global_context()->function_cache()->GetElement(serial_number);
+      Isolate::Current()->global_context()->function_cache()->
+          GetElement(serial_number);
   if (elm->IsJSFunction()) return Handle<JSFunction>(JSFunction::cast(elm));
   // The function has not yet been instantiated in this context; do it.
   Object** args[1] = { Handle<Object>::cast(data).location() };
   Handle<Object> result =
-      Call(Top::instantiate_fun(), Top::builtins(), 1, args, exc);
+      Call(Isolate::Current()->instantiate_fun(),
+           Isolate::Current()->builtins(), 1, args, exc);
   if (*exc) return Handle<JSFunction>::null();
   return Handle<JSFunction>::cast(result);
 }
 
 
 Handle<JSObject> Execution::InstantiateObject(Handle<ObjectTemplateInfo> data,
                                               bool* exc) {
   if (data->property_list()->IsUndefined() &&
       !data->constructor()->IsUndefined()) {
     // Initialization to make gcc happy.
     Object* result = NULL;
     {
       HandleScope scope;
       Handle<FunctionTemplateInfo> cons_template =
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(data->constructor()));
       Handle<JSFunction> cons = InstantiateFunction(cons_template, exc);
       if (*exc) return Handle<JSObject>::null();
       Handle<Object> value = New(cons, 0, NULL, exc);
       if (*exc) return Handle<JSObject>::null();
       result = *value;
     }
     ASSERT(!*exc);
     return Handle<JSObject>(JSObject::cast(result));
   } else {
     Object** args[1] = { Handle<Object>::cast(data).location() };
     Handle<Object> result =
-        Call(Top::instantiate_fun(), Top::builtins(), 1, args, exc);
+        Call(Isolate::Current()->instantiate_fun(),
+             Isolate::Current()->builtins(), 1, args, exc);
     if (*exc) return Handle<JSObject>::null();
     return Handle<JSObject>::cast(result);
   }
 }
 
 
 void Execution::ConfigureInstance(Handle<Object> instance,
                                   Handle<Object> instance_template,
                                   bool* exc) {
   Object** args[2] = { instance.location(), instance_template.location() };
-  Execution::Call(Top::configure_instance_fun(), Top::builtins(), 2, args, exc);
+  Execution::Call(Isolate::Current()->configure_instance_fun(),
+                  Isolate::Current()->builtins(), 2, args, exc);
 }
 
 
 Handle<String> Execution::GetStackTraceLine(Handle<Object> recv,
                                             Handle<JSFunction> fun,
                                             Handle<Object> pos,
                                             Handle<Object> is_global) {
   const int argc = 4;
   Object** args[argc] = { recv.location(),
                           Handle<Object>::cast(fun).location(),
                           pos.location(),
                           is_global.location() };
   bool caught_exception = false;
-  Handle<Object> result = TryCall(Top::get_stack_trace_line_fun(),
-                                  Top::builtins(), argc, args,
-                                  &caught_exception);
+  Handle<Object> result =
+      TryCall(Isolate::Current()->get_stack_trace_line_fun(),
+              Isolate::Current()->builtins(), argc, args, &caught_exception);
   if (caught_exception || !result->IsString()) return Factory::empty_symbol();
   return Handle<String>::cast(result);
 }
 
 
 static Object* RuntimePreempt() {
   Isolate* isolate = Isolate::Current();
 
   // Clear the preempt request flag.
   isolate->stack_guard()->Continue(PREEMPT);
@@ skipping 90 matching lines @@
   Isolate* isolate = Isolate::Current();
 #ifdef ENABLE_DEBUGGER_SUPPORT
   if (isolate->stack_guard()->IsDebugBreak() ||
       isolate->stack_guard()->IsDebugCommand()) {
     DebugBreakHelper();
   }
 #endif
   if (isolate->stack_guard()->IsPreempted()) RuntimePreempt();
   if (isolate->stack_guard()->IsTerminateExecution()) {
     isolate->stack_guard()->Continue(TERMINATE);
-    return Top::TerminateExecution();
+    return isolate->TerminateExecution();
   }
   if (isolate->stack_guard()->IsInterrupted()) {
     // interrupt
     isolate->stack_guard()->Continue(INTERRUPT);
-    return Top::StackOverflow();
+    return isolate->StackOverflow();
   }
   return isolate->heap()->undefined_value();
 }
 
 // --- G C   E x t e n s i o n ---
 
 const char* GCExtension::kSource = "native function gc();";
 
 
 v8::Handle<v8::FunctionTemplate> GCExtension::GetNativeFunction(
     v8::Handle<v8::String> str) {
   return v8::FunctionTemplate::New(GCExtension::GC);
 }
 
 
 v8::Handle<v8::Value> GCExtension::GC(const v8::Arguments& args) {
   // All allocation spaces other than NEW_SPACE have the same effect.
   HEAP->CollectAllGarbage(false);
   return v8::Undefined();
 }
 
 
 static GCExtension kGCExtension;
 v8::DeclareExtension kGCExtensionDeclaration(&kGCExtension);
 
 } }  // namespace v8::internal