Refactor Isolate -> Thread in NativeArguments and exception handler jump.

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
@@ skipping 102 matching lines @@
 
 static bool GetNativeStringArgument(NativeArguments* arguments,
                                     int arg_index,
                                     Dart_Handle* str,
                                     void** peer) {
   ASSERT(peer != NULL);
   if (Api::StringGetPeerHelper(arguments, arg_index, peer)) {
     *str = NULL;
     return true;
   }
-  Isolate* isolate = arguments->isolate();
+  Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
   *peer = NULL;
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   if (RawObject::IsStringClassId(obj.GetClassId())) {
     ASSERT(isolate->api_state() &&
            isolate->api_state()->top_scope() != NULL);
     *str = Api::NewHandle(isolate, obj.raw());
     return true;
   }
   if (obj.IsNull()) {
     *str = Api::Null();
     return true;
   }
   return false;
 }
 
 
 static bool GetNativeIntegerArgument(NativeArguments* arguments,
                                      int arg_index,
                                      int64_t* value) {
   ASSERT(value != NULL);
   if (Api::GetNativeIntegerArgument(arguments, arg_index, value)) {
     return true;
   }
-  Isolate* isolate = arguments->isolate();
+  Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   intptr_t cid = obj.GetClassId();
   if (cid == kBigintCid) {
     const Bigint& bigint = Bigint::Cast(obj);
     if (bigint.FitsIntoInt64()) {
       *value = bigint.AsInt64Value();
       return true;
     }
   }
   return false;
 }
 
 
 static bool GetNativeUnsignedIntegerArgument(NativeArguments* arguments,
                                              int arg_index,
                                              uint64_t* value) {
   ASSERT(value != NULL);
   int64_t arg_value = 0;
   if (Api::GetNativeIntegerArgument(arguments, arg_index, &arg_value)) {
     *value = static_cast<uint64_t>(arg_value);
     return true;
   }
-  Isolate* isolate = arguments->isolate();
+  Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   intptr_t cid = obj.GetClassId();
   if (cid == kBigintCid) {
     const Bigint& bigint = Bigint::Cast(obj);
     if (bigint.FitsIntoUint64()) {
       *value = bigint.AsUint64Value();
       return true;
     }
   }
   return false;
 }
 
 
 static bool GetNativeDoubleArgument(NativeArguments* arguments,
                                     int arg_index,
                                     double* value) {
   ASSERT(value != NULL);
   if (Api::GetNativeDoubleArgument(arguments, arg_index, value)) {
     return true;
   }
-  Isolate* isolate = arguments->isolate();
+  Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   intptr_t cid = obj.GetClassId();
   if (cid == kBigintCid) {
     *value = Bigint::Cast(obj).AsDoubleValue();
     return true;
   }
   return false;
 }
 
 
 static Dart_Handle GetNativeFieldsOfArgument(NativeArguments* arguments,
                                              int arg_index,
                                              int num_fields,
                                              intptr_t* field_values,
                                              const char* current_func) {
   ASSERT(field_values != NULL);
   if (Api::GetNativeFieldsOfArgument(arguments,
                                      arg_index,
                                      num_fields,
                                      field_values)) {
     return Api::Success();
   }
-  Isolate* isolate = arguments->isolate();
+  Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   if (obj.IsNull()) {
     memset(field_values, 0, (num_fields * sizeof(field_values[0])));
     return Api::Success();
   }
   // We did not succeed in extracting the native fields report the
   // appropriate error.
@@ skipping 244 matching lines @@
   }
   intptr_t cid = raw_obj->GetClassId();
   if (cid == kExternalOneByteStringCid) {
     RawExternalOneByteString* raw_string =
         reinterpret_cast<RawExternalOneByteString*>(raw_obj)->ptr();
     ExternalStringData<uint8_t>* data = raw_string->external_data_;
     *peer = data->peer();
     return true;
   }
   if (cid == kOneByteStringCid || cid == kTwoByteStringCid) {
-    Isolate* isolate = arguments->isolate();
+    Isolate* isolate = arguments->thread()->isolate();
     *peer = isolate->heap()->GetPeer(raw_obj);
     return (*peer != 0);
   }
   if (cid == kExternalTwoByteStringCid) {
     RawExternalTwoByteString* raw_string =
         reinterpret_cast<RawExternalTwoByteString*>(raw_obj)->ptr();
     ExternalStringData<uint16_t>* data = raw_string->external_data_;
     *peer = data->peer();
     return true;
   }
@@ skipping 2198 matching lines @@
 
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
                                      const String& dotted_name,
                                      int num_args);
 
 
 static RawObject* ThrowArgumentError(const char* exception_message) {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
   // Lookup the class ArgumentError in dart:core.
   const String& lib_url = String::Handle(String::New("dart:core"));
   const String& class_name = String::Handle(String::New("ArgumentError"));
   const Library& lib =
       Library::Handle(isolate, Library::LookupLibrary(lib_url));
   if (lib.IsNull()) {
     const String& message = String::Handle(
         String::NewFormatted("%s: library '%s' not found.",
                              CURRENT_FUNC, lib_url.ToCString()));
     return ApiError::New(message);
@@ skipping 37 matching lines @@
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Instance* saved_exception;
   {
     NoSafepointScope no_safepoint;
     RawInstance* raw_exception = exception.raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     saved_exception = &Instance::Handle(raw_exception);
   }
-  Exceptions::Throw(isolate, *saved_exception);
+  Exceptions::Throw(thread, *saved_exception);
   const String& message = String::Handle(
           String::New("Exception was not thrown, internal error"));
   return ApiError::New(message);
 }
 
 // TODO(sgjesse): value should always be smaller then 0xff. Add error handling.
 #define GET_LIST_ELEMENT_AS_BYTES(isolate, type, obj, native_array, offset,    \
                                   length)                                      \
   const type& array = type::Cast(obj);                                         \
   if (Utils::RangeCheck(offset, length, array.Length())) {                     \
@@ skipping 1651 matching lines @@
   }
   return Api::NewError(
       "%s expects argument 'container' to be an object, type, or library.",
       CURRENT_FUNC);
 }
 
 
 // --- Exceptions ----
 
 DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception) {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   {
     const Instance& excp = Api::UnwrapInstanceHandle(isolate, exception);
     if (excp.IsNull()) {
       RETURN_TYPE_ERROR(isolate, exception, Instance);
     }
   }
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // throw an exception here.
     return Api::NewError("No Dart frames on stack, cannot throw exception");
   }
 
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Instance* saved_exception;
   {
     NoSafepointScope no_safepoint;
     RawInstance* raw_exception =
         Api::UnwrapInstanceHandle(isolate, exception).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     saved_exception = &Instance::Handle(raw_exception);
   }
-  Exceptions::Throw(isolate, *saved_exception);
+  Exceptions::Throw(thread, *saved_exception);
   return Api::NewError("Exception was not thrown, internal error");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception,
                                               Dart_Handle stacktrace) {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   {
     const Instance& excp = Api::UnwrapInstanceHandle(isolate, exception);
     if (excp.IsNull()) {
       RETURN_TYPE_ERROR(isolate, exception, Instance);
     }
     const Instance& stk = Api::UnwrapInstanceHandle(isolate, stacktrace);
     if (stk.IsNull()) {
       RETURN_TYPE_ERROR(isolate, stacktrace, Instance);
@@ skipping 14 matching lines @@
   {
     NoSafepointScope no_safepoint;
     RawInstance* raw_exception =
         Api::UnwrapInstanceHandle(isolate, exception).raw();
     RawStacktrace* raw_stacktrace =
         Api::UnwrapStacktraceHandle(isolate, stacktrace).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     saved_exception = &Instance::Handle(raw_exception);
     saved_stacktrace = &Stacktrace::Handle(raw_stacktrace);
   }
-  Exceptions::ReThrow(isolate, *saved_exception, *saved_stacktrace);
+  Exceptions::ReThrow(thread, *saved_exception, *saved_stacktrace);
   return Api::NewError("Exception was not re thrown, internal error");
 }
 
 
 // --- Native fields and functions ---
 
 DART_EXPORT Dart_Handle Dart_CreateNativeWrapperClass(Dart_Handle library,
                                                       Dart_Handle name,
                                                       int field_count) {
   Isolate* isolate = Isolate::Current();
@@ skipping 71 matching lines @@
         "%s: invalid index %d passed in to set native instance field",
         CURRENT_FUNC, index);
   }
   instance.SetNativeField(index, value);
   return Api::Success();
 }
 
 
 DART_EXPORT void* Dart_GetNativeIsolateData(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  Isolate* isolate = arguments->isolate();
+  Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
   return isolate->init_callback_data();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeArguments(
     Dart_NativeArguments args,
     int num_arguments,
     const Dart_NativeArgument_Descriptor* argument_descriptors,
     Dart_NativeArgument_Value* arg_values) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  ASSERT(arguments->isolate() == Isolate::Current());
+  ASSERT(arguments->thread()->isolate() == Isolate::Current());
   if (arg_values == NULL) {
     RETURN_NULL_ERROR(arg_values);
   }
   for (int i = 0; i < num_arguments; i++) {
     Dart_NativeArgument_Descriptor desc = argument_descriptors[i];
     Dart_NativeArgument_Type arg_type = static_cast<Dart_NativeArgument_Type>(
         desc.type);
     int arg_index = desc.index;
     ASSERT(arg_index >= 0 && arg_index < arguments->NativeArgCount());
     Dart_NativeArgument_Value* native_value = &(arg_values[i]);
@@ skipping 89 matching lines @@
             native_value->as_native_fields.num_fields,
             native_value->as_native_fields.values,
             CURRENT_FUNC);
         if (result != Api::Success()) {
           return result;
         }
         break;
       }
 
       case Dart_NativeArgument_kInstance: {
-        Isolate* isolate = arguments->isolate();
+        Isolate* isolate = arguments->thread()->isolate();
         ASSERT(isolate == Isolate::Current());
         ASSERT(isolate->api_state() &&
                isolate->api_state()->top_scope() != NULL);
         native_value->as_instance =
             Api::NewHandle(isolate, arguments->NativeArgAt(arg_index));
         break;
       }
 
       default:
         return Api::NewError("%s: invalid argument type %d.",
                              CURRENT_FUNC, arg_type);
     }
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args,
                                                int index) {
   TRACE_API_CALL(CURRENT_FUNC);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   if ((index < 0) || (index >= arguments->NativeArgCount())) {
     return Api::NewError(
         "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
         CURRENT_FUNC, arguments->NativeArgCount() - 1, index);
   }
-  return Api::NewHandle(arguments->isolate(), arguments->NativeArgAt(index));
+  return Api::NewHandle(arguments->thread()->isolate(),
+                        arguments->NativeArgAt(index));
 }
 
 
 DART_EXPORT int Dart_GetNativeArgumentCount(Dart_NativeArguments args) {
   TRACE_API_CALL(CURRENT_FUNC);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   return arguments->NativeArgCount();
 }
 
 
@@ skipping 15 matching lines @@
                                    arg_index,
                                    num_fields,
                                    field_values,
                                    CURRENT_FUNC);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeReceiver(Dart_NativeArguments args,
                                                intptr_t* value) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  ASSERT(arguments->isolate() == Isolate::Current());
+  ASSERT(arguments->thread()->isolate() == Isolate::Current());
   if (value == NULL) {
     RETURN_NULL_ERROR(value);
   }
   if (Api::GetNativeReceiver(arguments, value)) {
     return Api::Success();
   }
   return Api::NewError("%s expects receiver argument to be non-null and of"
                        " type Instance.", CURRENT_FUNC);
 }
 
@@ skipping 61 matching lines @@
     return Api::NewError("%s: expects argument at %d to be of"
                          " type Double.", CURRENT_FUNC, index);
   }
   return Api::Success();
 }
 
 
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  ASSERT(arguments->isolate() == Isolate::Current());
+  ASSERT(arguments->thread()->isolate() == Isolate::Current());
   if ((retval != Api::Null()) && (!Api::IsInstance(retval))) {
     const Object& ret_obj = Object::Handle(Api::UnwrapHandle(retval));
     FATAL1("Return value check failed: saw '%s' expected a dart Instance.",
            ret_obj.ToCString());
   }
   ASSERT(retval != 0);
   Api::SetReturnValue(arguments, retval);
 }
 
 
 DART_EXPORT void Dart_SetWeakHandleReturnValue(Dart_NativeArguments args,
                                                Dart_WeakPersistentHandle rval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
 #if defined(DEBUG)
-  Isolate* isolate = arguments->isolate();
+  Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
   ASSERT(isolate->api_state() != NULL &&
          (isolate->api_state()->IsValidWeakPersistentHandle(rval) ||
           isolate->api_state()->IsValidPrologueWeakPersistentHandle(rval)));
 #endif
   Api::SetWeakHandleReturnValue(arguments, rval);
 }
 
 
 // --- Environment ---
@@ skipping 43 matching lines @@
                                             bool retval) {
   TRACE_API_CALL(CURRENT_FUNC);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   arguments->SetReturn(Bool::Get(retval));
 }
 
 
 DART_EXPORT void Dart_SetIntegerReturnValue(Dart_NativeArguments args,
                                             int64_t retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  ASSERT(arguments->isolate() == Isolate::Current());
+  ASSERT(arguments->thread()->isolate() == Isolate::Current());
   if (Smi::IsValid(retval)) {
     Api::SetSmiReturnValue(arguments, static_cast<intptr_t>(retval));
   } else {
     // Slow path for Mints and Bigints.
-    ASSERT_CALLBACK_STATE(arguments->isolate());
+    ASSERT_CALLBACK_STATE(arguments->thread()->isolate());
     Api::SetIntegerReturnValue(arguments, retval);
   }
 }
 
 
 DART_EXPORT void Dart_SetDoubleReturnValue(Dart_NativeArguments args,
                                            double retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
 #if defined(DEBUG)
-  Isolate* isolate = arguments->isolate();
+  Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
   ASSERT_CALLBACK_STATE(isolate);
 #endif
   Api::SetDoubleReturnValue(arguments, retval);
 }
 
 
 // --- Scripts and Libraries ---
 
 DART_EXPORT Dart_Handle Dart_SetLibraryTagHandler(
@@ skipping 602 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart