Rename NoGCScope -> NoSafepointScope.

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 454 matching lines @@
   null_handle_ = Api::InitNewHandle(isolate, Object::null());
 
   ASSERT(empty_string_handle_ == NULL);
   empty_string_handle_ = Api::InitNewHandle(isolate, Symbols::Empty().raw());
 }
 
 
 bool Api::StringGetPeerHelper(NativeArguments* arguments,
                               int arg_index,
                               void** peer) {
-  NoGCScope no_gc_scope;
+  NoSafepointScope no_safepoint_scope;
   RawObject* raw_obj = arguments->NativeArgAt(arg_index);
   if (!raw_obj->IsHeapObject()) {
     return false;
   }
   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();
     *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;
   }
   return false;
 }
 
 
 bool Api::GetNativeReceiver(NativeArguments* arguments, intptr_t* value) {
-  NoGCScope no_gc_scope;
+  NoSafepointScope no_safepoint_scope;
   RawObject* raw_obj = arguments->NativeArg0();
   if (raw_obj->IsHeapObject()) {
     intptr_t cid = raw_obj->GetClassId();
     if (cid > kNumPredefinedCids) {
       ASSERT(Instance::Cast(Object::Handle(raw_obj)).IsValidNativeIndex(0));
       RawTypedData* native_fields = *reinterpret_cast<RawTypedData**>(
           RawObject::ToAddr(raw_obj) + sizeof(RawObject));
       if (native_fields == TypedData::null()) {
         *value = 0;
       } else {
         *value = *bit_cast<intptr_t*, uint8_t*>(native_fields->ptr()->data());
       }
       return true;
     }
   }
   return false;
 }
 
 
 bool Api::GetNativeBooleanArgument(NativeArguments* arguments,
                                    int arg_index,
                                    bool* value) {
-  NoGCScope no_gc_scope;
+  NoSafepointScope no_safepoint_scope;
   RawObject* raw_obj = arguments->NativeArgAt(arg_index);
   if (raw_obj->IsHeapObject()) {
       intptr_t cid = raw_obj->GetClassId();
       if (cid == kBoolCid) {
         *value = (raw_obj == Object::bool_true().raw());
         return true;
       }
       if (cid == kNullCid) {
         *value = false;
         return true;
       }
   }
   return false;
 }
 
 
 bool Api::GetNativeIntegerArgument(NativeArguments* arguments,
                                    int arg_index,
                                    int64_t* value) {
-  NoGCScope no_gc_scope;
+  NoSafepointScope no_safepoint_scope;
   RawObject* raw_obj = arguments->NativeArgAt(arg_index);
   if (raw_obj->IsHeapObject()) {
     intptr_t cid = raw_obj->GetClassId();
     if (cid == kMintCid) {
       *value = reinterpret_cast<RawMint*>(raw_obj)->ptr()->value_;
       return true;
     }
     return false;
   }
   *value = Smi::Value(reinterpret_cast<RawSmi*>(raw_obj));
   return true;
 }
 
 
 bool Api::GetNativeDoubleArgument(NativeArguments* arguments,
                                   int arg_index,
                                   double* value) {
-  NoGCScope no_gc_scope;
+  NoSafepointScope no_safepoint_scope;
   RawObject* raw_obj = arguments->NativeArgAt(arg_index);
   if (raw_obj->IsHeapObject()) {
     intptr_t cid = raw_obj->GetClassId();
     if (cid == kDoubleCid) {
       *value = reinterpret_cast<RawDouble*>(raw_obj)->ptr()->value_;
       return true;
     }
     if (cid == kMintCid) {
       *value = static_cast<double>(
           reinterpret_cast<RawMint*>(raw_obj)->ptr()->value_);
       return true;
     }
     return false;
   }
   *value = static_cast<double>(Smi::Value(reinterpret_cast<RawSmi*>(raw_obj)));
   return true;
 }
 
 
 bool Api::GetNativeFieldsOfArgument(NativeArguments* arguments,
                                     int arg_index,
                                     int num_fields,
                                     intptr_t* field_values) {
-  NoGCScope no_gc_scope;
+  NoSafepointScope no_safepoint_scope;
   RawObject* raw_obj = arguments->NativeArgAt(arg_index);
   if (raw_obj->IsHeapObject()) {
     intptr_t cid = raw_obj->GetClassId();
     if (cid > kNumPredefinedCids) {
       RawTypedData* native_fields = *reinterpret_cast<RawTypedData**>(
           RawObject::ToAddr(raw_obj) + sizeof(RawObject));
       if (native_fields == TypedData::null()) {
         memset(field_values, 0, (num_fields * sizeof(field_values[0])));
       } else if (num_fields == Smi::Value(native_fields->ptr()->length_)) {
         intptr_t* native_values =
@@ skipping 185 matching lines @@
     // propagate an error here.
     return Api::NewError("No Dart frames on stack, cannot propagate error.");
   }
 
   // Unwind all the API scopes till the exit frame before propagating.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Error* error;
   {
     // We need to preserve the error object across the destruction of zones
-    // when the ApiScopes are unwound.  By using NoGCScope, we can ensure
+    // when the ApiScopes are unwound.  By using NoSafepointScope, we can ensure
     // that GC won't touch the raw error object before creating a valid
     // handle for it in the surviving zone.
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     RawError* raw_error = Api::UnwrapErrorHandle(isolate, handle).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     error = &Error::Handle(isolate, raw_error);
   }
   Exceptions::PropagateError(*error);
   UNREACHABLE();
   return Api::NewError("Cannot reach here.  Internal error.");
 }
 
 
@@ skipping 22 matching lines @@
     // This is a VM internal object. Call the C++ method of printing.
     return Api::NewHandle(isolate, String::New(obj.ToCString()));
   }
 }
 
 
 DART_EXPORT bool Dart_IdentityEquals(Dart_Handle obj1, Dart_Handle obj2) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   {
-    NoGCScope ngc;
+    NoSafepointScope no_safepoint_scope;
     if (Api::UnwrapHandle(obj1) == Api::UnwrapHandle(obj2)) {
       return true;
     }
   }
   const Object& object1 = Object::Handle(isolate, Api::UnwrapHandle(obj1));
   const Object& object2 = Object::Handle(isolate, Api::UnwrapHandle(obj2));
   if (object1.IsInstance() && object2.IsInstance()) {
     return Instance::Cast(object1).IsIdenticalTo(Instance::Cast(object2));
   }
   return false;
@@ skipping 296 matching lines @@
 
 class PrologueWeakVisitor : public HandleVisitor {
  public:
   PrologueWeakVisitor(Isolate* isolate,
                       Dart_GcPrologueWeakHandleCallback callback)
       :  HandleVisitor(isolate),
          callback_(callback) {
   }
 
   void VisitHandle(uword addr) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     FinalizablePersistentHandle* handle =
         reinterpret_cast<FinalizablePersistentHandle*>(addr);
     RawObject* raw_obj = handle->raw();
     if (raw_obj->IsHeapObject()) {
       ASSERT(handle->IsPrologueWeakPersistent());
       ReusableInstanceHandleScope reused_instance_handle(isolate());
       Instance& instance = reused_instance_handle.Handle();
       instance ^= reinterpret_cast<RawInstance*>(handle->raw());
       intptr_t num_native_fields = instance.NumNativeFields();
       intptr_t* native_fields = instance.NativeFieldsDataAddr();
@@ skipping 1277 matching lines @@
   CHECK_ISOLATE(isolate);
   ReusableObjectHandleScope reused_obj_handle(isolate);
   const String& str = Api::UnwrapStringHandle(reused_obj_handle, object);
   if (str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, String);
   }
   if (str.IsExternal()) {
     *peer = str.GetPeer();
     ASSERT(*peer != NULL);
   } else {
-    NoGCScope no_gc_scope;
+    NoSafepointScope no_safepoint_scope;
     *peer = isolate->heap()->GetPeer(str.raw());
   }
   *char_size = str.CharSize();
   *str_len = str.Length();
   return Api::Success();
 }
 
 
 // --- Lists ---
 
@@ skipping 238 matching lines @@
     const String& message = String::Handle(
             String::New("No Dart frames on stack, cannot throw exception"));
     return ApiError::New(message);
   }
   // 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;
   {
-    NoGCScope no_gc;
+    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);
   const String& message = String::Handle(
           String::New("Exception was not thrown, internal error"));
   return ApiError::New(message);
 }
 
@@ skipping 17 matching lines @@
     return Api::Success();                                                     \
   }                                                                            \
   return Api::NewError("Invalid length passed in to access array elements");   \
 
 template<typename T>
 static Dart_Handle CopyBytes(const T& array,
                              intptr_t offset,
                              uint8_t* native_array,
                              intptr_t length) {
   ASSERT(array.ElementSizeInBytes() == 1);
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   memmove(native_array,
           reinterpret_cast<uint8_t*>(array.DataAddr(offset)),
           length);
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
@@ skipping 122 matching lines @@
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsTypedData()) {
     const TypedData& array = TypedData::Cast(obj);
     if (array.ElementSizeInBytes() == 1) {
       if (Utils::RangeCheck(offset, length, array.Length())) {
-        NoGCScope no_gc;
+        NoSafepointScope no_safepoint;
         memmove(reinterpret_cast<uint8_t*>(array.DataAddr(offset)),
                 native_array,
                 length);
         return Api::Success();
       }
       return Api::NewError("Invalid length passed in to access list elements");
     }
   }
   if (obj.IsArray() && !Array::Cast(obj).IsImmutable()) {
     // If the list is immutable we call into Dart for the indexed setter to
@@ skipping 556 matching lines @@
     length = obj.Length();
     size_in_bytes = length * ExternalTypedData::ElementSizeInBytes(class_id);
     data_tmp = obj.DataAddr(0);
     external = true;
   } else if (RawObject::IsTypedDataClassId(class_id)) {
     // Regular typed data object, set up some GC and API callback guards.
     const TypedData& obj = Api::UnwrapTypedDataHandle(isolate, object);
     ASSERT(!obj.IsNull());
     length = obj.Length();
     size_in_bytes = length * TypedData::ElementSizeInBytes(class_id);
-    isolate->IncrementNoGCScopeDepth();
+    isolate->IncrementNoSafepointScopeDepth();
     START_NO_CALLBACK_SCOPE(isolate);
     data_tmp = obj.DataAddr(0);
   } else {
     ASSERT(RawObject::IsTypedDataViewClassId(class_id));
     const Instance& view_obj = Api::UnwrapInstanceHandle(isolate, object);
     ASSERT(!view_obj.IsNull());
     Smi& val = Smi::Handle();
     val ^= TypedDataView::Length(view_obj);
     length = val.Value();
     size_in_bytes = length * TypedDataView::ElementSizeInBytes(class_id);
     val ^= TypedDataView::OffsetInBytes(view_obj);
     intptr_t offset_in_bytes = val.Value();
     const Instance& obj = Instance::Handle(TypedDataView::Data(view_obj));
-    isolate->IncrementNoGCScopeDepth();
+    isolate->IncrementNoSafepointScopeDepth();
     START_NO_CALLBACK_SCOPE(isolate);
     if (TypedData::IsTypedData(obj)) {
       const TypedData& data_obj = TypedData::Cast(obj);
       data_tmp = data_obj.DataAddr(offset_in_bytes);
     } else {
       ASSERT(ExternalTypedData::IsExternalTypedData(obj));
       const ExternalTypedData& data_obj = ExternalTypedData::Cast(obj);
       data_tmp = data_obj.DataAddr(offset_in_bytes);
       external = true;
     }
@@ skipping 21 matching lines @@
 DART_EXPORT Dart_Handle Dart_TypedDataReleaseData(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   intptr_t class_id = Api::ClassId(object);
   if (!RawObject::IsExternalTypedDataClassId(class_id) &&
       !RawObject::IsTypedDataViewClassId(class_id) &&
       !RawObject::IsTypedDataClassId(class_id)) {
     RETURN_TYPE_ERROR(isolate, object, 'TypedData');
   }
   if (!RawObject::IsExternalTypedDataClassId(class_id)) {
-    isolate->DecrementNoGCScopeDepth();
+    isolate->DecrementNoSafepointScopeDepth();
     END_NO_CALLBACK_SCOPE(isolate);
   }
   if (FLAG_verify_acquired_data) {
     const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
     WeakTable* table = isolate->api_state()->acquired_table();
     intptr_t current = table->GetValue(obj.raw());
     if (current == 0) {
       return Api::NewError("Data was not acquired for this object.");
     }
     AcquiredData* ad = reinterpret_cast<AcquiredData*>(current);
@@ skipping 863 matching lines @@
     // 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;
   {
-    NoGCScope no_gc;
+    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);
   return Api::NewError("Exception was not thrown, internal error");
 }
 
 
@@ skipping 18 matching lines @@
     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;
   const Stacktrace* saved_stacktrace;
   {
-    NoGCScope no_gc;
+    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);
   return Api::NewError("Exception was not re thrown, internal error");
@@ skipping 999 matching lines @@
   CHECK_ISOLATE(isolate);
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = Api::UnwrapHandle(object);
   if (obj.IsNull() || obj.IsNumber() || obj.IsBool()) {
     const char* msg =
         "%s: argument 'object' cannot be a subtype of Null, num, or bool";
     return Api::NewError(msg, CURRENT_FUNC);
   }
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     RawObject* raw_obj = obj.raw();
     *peer = isolate->heap()->GetPeer(raw_obj);
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetPeer(Dart_Handle object, void* peer) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = Api::UnwrapHandle(object);
   if (obj.IsNull() || obj.IsNumber() || obj.IsBool()) {
     const char* msg =
         "%s: argument 'object' cannot be a subtype of Null, num, or bool";
     return Api::NewError(msg, CURRENT_FUNC);
   }
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success();
 }
 
 
 // --- Service support ---
 
 DART_EXPORT bool Dart_IsServiceIsolate(Dart_Isolate isolate) {
@@ skipping 16 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart