Use a bit in the handle structure to indicate if it is a prologue weak handle instead of the taggin…

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 347 matching lines @@
 }
 
 
 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);
+  return reinterpret_cast<FinalizablePersistentHandle*>(handle);
 }
 
 
-void FinalizablePersistentHandle::Finalize(Isolate* isolate,
-                                           FinalizablePersistentHandle* handle,
-                                           bool is_prologue_weak) {
+void FinalizablePersistentHandle::Finalize(
+    Isolate* isolate, FinalizablePersistentHandle* handle) {
   if (!handle->raw()->IsHeapObject()) {
     return;
   }
   Dart_WeakPersistentHandleFinalizer callback = handle->callback();
   ASSERT(callback != NULL);
   void* peer = handle->peer();
-  Dart_WeakPersistentHandle object = is_prologue_weak ?
-      handle->apiPrologueHandle() :
-      handle->apiHandle();
+  Dart_WeakPersistentHandle object = handle->apiHandle();
   (*callback)(isolate->init_callback_data(), object, peer);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  if (is_prologue_weak) {
+  if (handle->IsPrologueWeakPersistent()) {
     state->prologue_weak_persistent_handles().FreeHandle(handle);
   } else {
     state->weak_persistent_handles().FreeHandle(handle);
   }
 }
 
 
 // --- Handles ---
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
@@ skipping 255 matching lines @@
   Object& ref = isolate->ObjectHandle();
   ref = Api::UnwrapHandle(object);
   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);
   finalizable_ref->SetExternalSize(external_allocation_size, isolate);
-  if (is_prologue) {
-    return finalizable_ref->apiPrologueHandle();
-  } else {
-    return finalizable_ref->apiHandle();
-  }
+  finalizable_ref->SetPrologueWeakPersistent(is_prologue);
+  return finalizable_ref->apiHandle();
 }
 
 
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     intptr_t external_allocation_size,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
@@ skipping 42 matching lines @@
 
 
 DART_EXPORT void Dart_DeleteWeakPersistentHandle(
     Dart_Isolate current_isolate,
     Dart_WeakPersistentHandle object) {
   Isolate* isolate = reinterpret_cast<Isolate*>(current_isolate);
   CHECK_ISOLATE(isolate);
   ASSERT(isolate == Isolate::Current());
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  if (FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object)) {
+  FinalizablePersistentHandle* weak_ref =
+      FinalizablePersistentHandle::Cast(object);
+  weak_ref->EnsureFreeExternal(isolate);
+  if (weak_ref->IsPrologueWeakPersistent()) {
     ASSERT(state->IsValidPrologueWeakPersistentHandle(object));
-    FinalizablePersistentHandle* weak_ref =
-        FinalizablePersistentHandle::Cast(object);
-    weak_ref->EnsureFreeExternal(isolate);
     state->prologue_weak_persistent_handles().FreeHandle(weak_ref);
   } else {
     ASSERT(!state->IsValidPrologueWeakPersistentHandle(object));
-    FinalizablePersistentHandle* weak_ref =
-        FinalizablePersistentHandle::Cast(object);
-    weak_ref->EnsureFreeExternal(isolate);
     state->weak_persistent_handles().FreeHandle(weak_ref);
   }
 }
 
 
 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);
-  ASSERT(state->IsValidPrologueWeakPersistentHandle(object) ==
-         FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object));
-#endif
-  return FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object);
+  FinalizablePersistentHandle* weak_ref =
+      FinalizablePersistentHandle::Cast(object);
+  return weak_ref->IsPrologueWeakPersistent();
 }
 
 
 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 3888 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart