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

src/builtins.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 130 matching lines @@
 #ifdef DEBUG
   // Calculate the result using a full stack frame iterator and check
   // that the state of the stack is as we assume it to be in the
   // code below.
   StackFrameIterator it;
   ASSERT(it.frame()->is_exit());
   it.Advance();
   StackFrame* frame = it.frame();
   bool reference_result = frame->is_construct();
 #endif
-  Address fp = Top::c_entry_fp(Isolate::Current()->thread_local_top());
+  Address fp = Isolate::c_entry_fp(Isolate::Current()->thread_local_top());
   // Because we know fp points to an exit frame we can use the relevant
   // part of ExitFrame::ComputeCallerState directly.
   const int kCallerOffset = ExitFrameConstants::kCallerFPOffset;
   Address caller_fp = Memory::Address_at(fp + kCallerOffset);
   // This inlines the part of StackFrame::ComputeType that grabs the
   // type of the current frame.  Note that StackFrame::ComputeType
   // has been specialized for each architecture so if any one of them
   // changes this code has to be changed as well.
   const int kMarkerOffset = StandardFrameConstants::kMarkerOffset;
   const Smi* kConstructMarker = Smi::FromInt(StackFrame::CONSTRUCT);
@@ skipping 19 matching lines @@
 
 BUILTIN(ArrayCodeGeneric) {
   Counters::array_function_runtime.Increment();
 
   JSArray* array;
   if (CalledAsConstructor()) {
     array = JSArray::cast(*args.receiver());
   } else {
     // Allocate the JS Array
     JSFunction* constructor =
-        Top::context()->global_context()->array_function();
+        Isolate::Current()->context()->global_context()->array_function();
     Object* obj = HEAP->AllocateJSObject(constructor);
     if (obj->IsFailure()) return obj;
     array = JSArray::cast(obj);
   }
 
   // 'array' now contains the JSArray we should initialize.
 
   // Optimize the case where there is one argument and the argument is a
   // small smi.
   if (args.length() == 2) {
@@ skipping 35 matching lines @@
   // Set length and elements on the array.
   array->set_elements(FixedArray::cast(obj));
   array->set_length(len);
 
   return array;
 }
 
 
 static Object* AllocateJSArray() {
   JSFunction* array_function =
-      Top::context()->global_context()->array_function();
+      Isolate::Current()->context()->global_context()->array_function();
   Object* result = HEAP->AllocateJSObject(array_function);
   if (result->IsFailure()) return result;
   return result;
 }
 
 
 static Object* AllocateEmptyJSArray() {
   Object* result = AllocateJSArray();
   if (result->IsFailure()) return result;
   JSArray* result_array = JSArray::cast(result);
@@ skipping 104 matching lines @@
 
   *elements = FixedArray::cast(elms);
   return true;
 }
 
 
 static bool IsFastElementMovingAllowed(Object* receiver,
                                        FixedArray** elements) {
   if (!IsJSArrayWithFastElements(receiver, elements)) return false;
 
-  Context* global_context = Top::context()->global_context();
+  Context* global_context = Isolate::Current()->context()->global_context();
   JSObject* array_proto =
       JSObject::cast(global_context->array_function()->prototype());
   if (JSArray::cast(receiver)->GetPrototype() != array_proto) return false;
   return ArrayPrototypeHasNoElements(global_context, array_proto);
 }
 
 
 static Object* CallJsBuiltin(const char* name,
                              BuiltinArguments<NO_EXTRA_ARGUMENTS> args) {
   HandleScope handleScope;
 
   Handle<Object> js_builtin =
-      GetProperty(Handle<JSObject>(Top::global_context()->builtins()),
-                  name);
+      GetProperty(Handle<JSObject>(
+          Isolate::Current()->global_context()->builtins()),
+          name);
   ASSERT(js_builtin->IsJSFunction());
   Handle<JSFunction> function(Handle<JSFunction>::cast(js_builtin));
   ScopedVector<Object**> argv(args.length() - 1);
   int n_args = args.length() - 1;
   for (int i = 0; i < n_args; i++) {
     argv[i] = args.at<Object>(i + 1).location();
   }
   bool pending_exception = false;
   Handle<Object> result = Execution::Call(function,
                                           args.receiver(),
@@ skipping 385 matching lines @@
   }
 
   // Set the length.
   array->set_length(Smi::FromInt(new_length));
 
   return result_array;
 }
 
 
 BUILTIN(ArrayConcat) {
-  Context* global_context = Top::context()->global_context();
+  Context* global_context = Isolate::Current()->context()->global_context();
   JSObject* array_proto =
       JSObject::cast(global_context->array_function()->prototype());
   if (!ArrayPrototypeHasNoElements(global_context, array_proto)) {
     return CallJsBuiltin("ArrayConcat", args);
   }
 
   // Iterate through all the arguments performing checks
   // and calculating total length.
   int n_arguments = args.length();
   int result_len = 0;
@@ skipping 113 matching lines @@
   HandleScope scope;
   Handle<JSFunction> function = args.called_function();
   ASSERT(function->shared()->IsApiFunction());
 
   FunctionTemplateInfo* fun_data = function->shared()->get_api_func_data();
   if (is_construct) {
     Handle<FunctionTemplateInfo> desc(fun_data);
     bool pending_exception = false;
     Factory::ConfigureInstance(desc, Handle<JSObject>::cast(args.receiver()),
                                &pending_exception);
-    ASSERT(Top::has_pending_exception() == pending_exception);
+    ASSERT(Isolate::Current()->has_pending_exception() == pending_exception);
     if (pending_exception) return Failure::Exception();
     fun_data = *desc;
   }
 
   Object* raw_holder = TypeCheck(args.length(), &args[0], fun_data);
 
   if (raw_holder->IsNull()) {
     // This function cannot be called with the given receiver.  Abort!
     Handle<Object> obj =
         Factory::NewTypeError("illegal_invocation", HandleVector(&function, 1));
-    return Top::Throw(*obj);
+    return Isolate::Current()->Throw(*obj);
   }
 
   Object* raw_call_data = fun_data->call_code();
   if (!raw_call_data->IsUndefined()) {
     CallHandlerInfo* call_data = CallHandlerInfo::cast(raw_call_data);
     Object* callback_obj = call_data->callback();
     v8::InvocationCallback callback =
         v8::ToCData<v8::InvocationCallback>(callback_obj);
     Object* data_obj = call_data->data();
     Object* result;
@@ skipping 566 matching lines @@
       if (entry->contains(pc)) {
         return names_[i];
       }
     }
   }
   return NULL;
 }
 
 
 } }  // namespace v8::internal