Use a tag bit for indicating prologue weak persistent handles, this avoids

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/bigint_operations.h"
@@ skipping 137 matching lines @@
     const ReusableObjectHandleScope& reuse, Dart_Handle dart_handle) {
   Object& ref = reuse.Handle();
   ref = Api::UnwrapHandle(dart_handle);
   if (ref.IsInstance()) {
     return Instance::Cast(ref);
   }
   return Object::null_instance();
 }
 
 
-PersistentHandle* Api::UnwrapAsPersistentHandle(Dart_PersistentHandle object) {
-  ASSERT(Isolate::Current()->api_state()->IsValidPersistentHandle(object));
-  return reinterpret_cast<PersistentHandle*>(object);
-}
-
-
-FinalizablePersistentHandle* Api::UnwrapAsWeakPersistentHandle(
-    Dart_WeakPersistentHandle object) {
-  ASSERT(Isolate::Current()->api_state()->IsValidWeakPersistentHandle(object) ||
-         Isolate::Current()->api_state()->
-             IsValidPrologueWeakPersistentHandle(object));
-  return reinterpret_cast<FinalizablePersistentHandle*>(object);
-}
-
-
-FinalizablePersistentHandle* Api::UnwrapAsPrologueWeakPersistentHandle(
-    Dart_WeakPersistentHandle object) {
-  ASSERT(Isolate::Current()->api_state()->IsValidPrologueWeakPersistentHandle(
-      object));
-  return reinterpret_cast<FinalizablePersistentHandle*>(object);
-}
-
-
 Dart_Handle Api::CheckIsolateState(Isolate* isolate) {
   if (!isolate->AllowClassFinalization()) {
     // Class finalization is blocked for the isolate. Do nothing.
     return Api::Success();
   }
   if (ClassFinalizer::ProcessPendingClasses()) {
     return Api::Success();
   }
   ASSERT(isolate->object_store()->sticky_error() != Object::null());
   return Api::NewHandle(isolate, isolate->object_store()->sticky_error());
@@ skipping 160 matching lines @@
         *value = false;
         return true;
       }
   }
   return false;
 }
 
 
 void Api::SetWeakHandleReturnValue(NativeArguments* args,
                                    Dart_WeakPersistentHandle retval) {
-  args->SetReturnUnsafe(Api::UnwrapAsWeakPersistentHandle(retval)->raw());
+  args->SetReturnUnsafe(FinalizablePersistentHandle::Cast(retval)->raw());
+}
+
+
+PersistentHandle* PersistentHandle::Cast(Dart_PersistentHandle handle) {
+  ASSERT(Isolate::Current()->api_state()->IsValidPersistentHandle(handle));
+  return reinterpret_cast<PersistentHandle*>(handle);
+}
+
+
+FinalizablePersistentHandle* FinalizablePersistentHandle::Cast(
+    Dart_WeakPersistentHandle handle) {
+#if defined(DEBUG)
+  ApiState* state = Isolate::Current()->api_state();
+  ASSERT(state->IsValidWeakPersistentHandle(handle) ||
+         state->IsValidPrologueWeakPersistentHandle(handle));
+#endif
+  uword addr = reinterpret_cast<uword>(handle);
+  return reinterpret_cast<FinalizablePersistentHandle*>(
+      addr & ~kWeakPersistentTagMask);
 }
 
 
 // --- Handles ---
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
   TRACE_API_CALL(CURRENT_FUNC);
   return RawObject::IsErrorClassId(Api::ClassId(handle));
 }
 
@@ skipping 189 matching lines @@
   return false;
 }
 
 
 DART_EXPORT Dart_Handle Dart_HandleFromPersistent(
     Dart_PersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  ASSERT(state->IsValidPersistentHandle(object));
-  return Api::NewHandle(isolate,
-                        reinterpret_cast<PersistentHandle*>(object)->raw());
+  PersistentHandle* ref = PersistentHandle::Cast(object);
+  return Api::NewHandle(isolate, ref->raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_HandleFromWeakPersistent(
     Dart_WeakPersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  ASSERT(state->IsValidWeakPersistentHandle(object) ||
-         state->IsValidPrologueWeakPersistentHandle(object));
-  return Api::NewHandle(
-      isolate, reinterpret_cast<FinalizablePersistentHandle*>(object)->raw());
+  FinalizablePersistentHandle* weak_ref =
+      FinalizablePersistentHandle::Cast(object);
+  return Api::NewHandle(isolate, weak_ref->raw());
 }
 
 
 DART_EXPORT Dart_PersistentHandle Dart_NewPersistentHandle(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Object& old_ref = Object::Handle(isolate, Api::UnwrapHandle(object));
   PersistentHandle* new_ref = state->persistent_handles().AllocateHandle();
   new_ref->set_raw(old_ref);
-  return reinterpret_cast<Dart_PersistentHandle>(new_ref);
+  return new_ref->apiHandle();
 }
 
 
 DART_EXPORT void Dart_SetPersistentHandle(Dart_PersistentHandle obj1,
                                           Dart_Handle obj2) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ASSERT(state->IsValidPersistentHandle(obj1));
   const Object& obj2_ref = Object::Handle(isolate, Api::UnwrapHandle(obj2));
-  PersistentHandle* obj1_ref = Api::UnwrapAsPersistentHandle(obj1);
+  PersistentHandle* obj1_ref = PersistentHandle::Cast(obj1);
   obj1_ref->set_raw(obj2_ref);
 }
 
 
 static Dart_WeakPersistentHandle AllocateFinalizableHandle(
     Isolate* isolate,
-    FinalizablePersistentHandles* handles,
     Dart_Handle object,
+    bool is_prologue,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
   ReusableObjectHandleScope reused_obj_handle(isolate);
   Object& ref = reused_obj_handle.Handle();
   ref = Api::UnwrapHandle(object);
-  FinalizablePersistentHandle* finalizable_ref = handles->AllocateHandle();
+  FinalizablePersistentHandle* finalizable_ref = is_prologue ?
+      state->prologue_weak_persistent_handles().AllocateHandle() :
+      state->weak_persistent_handles().AllocateHandle();
+
   finalizable_ref->set_raw(ref);
   finalizable_ref->set_peer(peer);
   finalizable_ref->set_callback(callback);
-  return reinterpret_cast<Dart_WeakPersistentHandle>(finalizable_ref);
+  if (is_prologue) {
+    return finalizable_ref->apiPrologueHandle();
+  } else {
+    return finalizable_ref->apiHandle();
+  }
 }
 
 
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
-  ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
-                                   &state->weak_persistent_handles(),
                                    object,
+                                   false,
                                    peer,
                                    callback);
 }
 
 
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewPrologueWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
-  ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
-                                   &state->prologue_weak_persistent_handles(),
                                    object,
+                                   true,
                                    peer,
                                    callback);
 }
 
 
 DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  PersistentHandle* ref = Api::UnwrapAsPersistentHandle(object);
+  PersistentHandle* ref = PersistentHandle::Cast(object);
   ASSERT(!state->IsProtectedHandle(ref));
   if (!state->IsProtectedHandle(ref)) {
     state->persistent_handles().FreeHandle(ref);
   }
 }
 
 
 DART_EXPORT void Dart_DeleteWeakPersistentHandle(
     Dart_WeakPersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  if (state->IsValidPrologueWeakPersistentHandle(object)) {
-    FinalizablePersistentHandle* prologue_weak_ref =
-        Api::UnwrapAsPrologueWeakPersistentHandle(object);
-    state->prologue_weak_persistent_handles().FreeHandle(prologue_weak_ref);
-    return;
+  if (FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object)) {
+    ASSERT(state->IsValidPrologueWeakPersistentHandle(object));
+    FinalizablePersistentHandle* weak_ref =
+        FinalizablePersistentHandle::Cast(object);
+    state->prologue_weak_persistent_handles().FreeHandle(weak_ref);
+  } else {
+    ASSERT(!state->IsValidPrologueWeakPersistentHandle(object));
+    FinalizablePersistentHandle* weak_ref =
+        FinalizablePersistentHandle::Cast(object);
+    state->weak_persistent_handles().FreeHandle(weak_ref);
   }
-  FinalizablePersistentHandle* weak_ref =
-      Api::UnwrapAsWeakPersistentHandle(object);
-  state->weak_persistent_handles().FreeHandle(weak_ref);
-  return;
 }
 
 
 DART_EXPORT bool Dart_IsPrologueWeakPersistentHandle(
     Dart_WeakPersistentHandle object) {
+#if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  return state->IsValidPrologueWeakPersistentHandle(object);
+  ASSERT(state->IsValidPrologueWeakPersistentHandle(object) ==
+         FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object));
+#endif
+  return FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewWeakReferenceSet(
     Dart_WeakPersistentHandle* keys,
     intptr_t num_keys,
     Dart_WeakPersistentHandle* values,
     intptr_t num_values) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
@@ skipping 3894 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart