Rename NoGCScope -> NoSafepointScope.

runtime/vm/snapshot.cc

 // Copyright (c) 2012, 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 "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_entry.h"
@@ skipping 478 matching lines @@
   RawApiError* error = VerifyVersion();
   if (error != ApiError::null()) {
     return error;
   }
 
   // The version string matches. Read the rest of the snapshot.
 
   // TODO(asiva): Add a check here to ensure we have the right heap
   // size for the full snapshot being read.
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     HeapLocker hl(isolate, old_space());
 
     // Read in all the objects stored in the object store.
     intptr_t num_flds = (object_store->to() - object_store->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
       *(object_store->from() + i) = ReadObjectImpl();
     }
     for (intptr_t i = 0; i < backward_references_.length(); i++) {
       if (!backward_references_[i].is_deserialized()) {
         ReadObjectImpl();
@@ skipping 74 matching lines @@
     const String& msg = String::Handle(String::New(message_buffer));
     return ApiError::New(msg);
   }
   Advance(version_len);
   return ApiError::null();
 }
 
 
 #define ALLOC_NEW_OBJECT_WITH_LEN(type, length)                                \
   ASSERT(kind_ == Snapshot::kFull);                                            \
-  ASSERT(isolate()->no_gc_scope_depth() != 0);                                 \
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);                          \
   Raw##type* obj = reinterpret_cast<Raw##type*>(                               \
       AllocateUninitialized(k##type##Cid, type::InstanceSize(length)));        \
   obj->StoreSmi(&(obj->ptr()->length_), Smi::New(length));                     \
   return obj;                                                                  \
 
 
 RawArray* SnapshotReader::NewArray(intptr_t len) {
   ALLOC_NEW_OBJECT_WITH_LEN(Array, len);
 }
 
@@ skipping 13 matching lines @@
 }
 
 
 RawTypeArguments* SnapshotReader::NewTypeArguments(intptr_t len) {
   ALLOC_NEW_OBJECT_WITH_LEN(TypeArguments, len);
 }
 
 
 RawTokenStream* SnapshotReader::NewTokenStream(intptr_t len) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   stream_ = reinterpret_cast<RawTokenStream*>(
       AllocateUninitialized(kTokenStreamCid, TokenStream::InstanceSize()));
   uint8_t* array = const_cast<uint8_t*>(CurrentBufferAddress());
   ASSERT(array != NULL);
   Advance(len);
   data_ = reinterpret_cast<RawExternalTypedData*>(
       AllocateUninitialized(kExternalTypedDataUint8ArrayCid,
                             ExternalTypedData::InstanceSize()));
   data_.SetData(array);
   data_.SetLength(len);
   stream_.SetStream(data_);
   return stream_.raw();
 }
 
 
 RawContext* SnapshotReader::NewContext(intptr_t num_variables) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   RawContext* obj = reinterpret_cast<RawContext*>(
       AllocateUninitialized(kContextCid, Context::InstanceSize(num_variables)));
   obj->ptr()->num_variables_ = num_variables;
   return obj;
 }
 
 
 RawClass* SnapshotReader::NewClass(intptr_t class_id) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   if (class_id < kNumPredefinedCids) {
     ASSERT((class_id >= kInstanceCid) &&
            (class_id <= kNullCid));
     return isolate()->class_table()->At(class_id);
   }
   RawClass* obj = reinterpret_cast<RawClass*>(
       AllocateUninitialized(kClassCid, Class::InstanceSize()));
   Instance fake;
   obj->ptr()->handle_vtable_ = fake.vtable();
   cls_ = obj;
   cls_.set_id(class_id);
   isolate()->RegisterClassAt(class_id, cls_);
   return cls_.raw();
 }
 
 
 RawInstance* SnapshotReader::NewInstance() {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   RawInstance* obj = reinterpret_cast<RawInstance*>(
       AllocateUninitialized(kObjectCid, Instance::InstanceSize()));
   return obj;
 }
 
 
 RawMint* SnapshotReader::NewMint(int64_t value) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   RawMint* obj = reinterpret_cast<RawMint*>(
       AllocateUninitialized(kMintCid, Mint::InstanceSize()));
   obj->ptr()->value_ = value;
   return obj;
 }
 
 
 RawDouble* SnapshotReader::NewDouble(double value) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   RawDouble* obj = reinterpret_cast<RawDouble*>(
       AllocateUninitialized(kDoubleCid, Double::InstanceSize()));
   obj->ptr()->value_ = value;
   return obj;
 }
 
 
 RawTypedData* SnapshotReader::NewTypedData(intptr_t class_id, intptr_t len) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   const intptr_t lengthInBytes = len * TypedData::ElementSizeInBytes(class_id);
   RawTypedData* obj = reinterpret_cast<RawTypedData*>(
       AllocateUninitialized(class_id, TypedData::InstanceSize(lengthInBytes)));
   obj->StoreSmi(&(obj->ptr()->length_), Smi::New(len));
   return obj;
 }
 
 
 #define ALLOC_NEW_OBJECT(type)                                                 \
   ASSERT(kind_ == Snapshot::kFull);                                            \
-  ASSERT(isolate()->no_gc_scope_depth() != 0);                                 \
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);                          \
   return reinterpret_cast<Raw##type*>(                                         \
       AllocateUninitialized(k##type##Cid, type::InstanceSize()));              \
 
 
 RawBigint* SnapshotReader::NewBigint() {
   ALLOC_NEW_OBJECT(Bigint);
 }
 
 
 RawUnresolvedClass* SnapshotReader::NewUnresolvedClass() {
@@ skipping 77 matching lines @@
 
 
 RawGrowableObjectArray* SnapshotReader::NewGrowableObjectArray() {
   ALLOC_NEW_OBJECT(GrowableObjectArray);
 }
 
 
 RawFloat32x4* SnapshotReader::NewFloat32x4(float v0, float v1, float v2,
                                            float v3) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   RawFloat32x4* obj = reinterpret_cast<RawFloat32x4*>(
       AllocateUninitialized(kFloat32x4Cid, Float32x4::InstanceSize()));
   obj->ptr()->value_[0] = v0;
   obj->ptr()->value_[1] = v1;
   obj->ptr()->value_[2] = v2;
   obj->ptr()->value_[3] = v3;
   return obj;
 }
 
 
 RawInt32x4* SnapshotReader::NewInt32x4(uint32_t v0, uint32_t v1, uint32_t v2,
                                        uint32_t v3) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   RawInt32x4* obj = reinterpret_cast<RawInt32x4*>(
       AllocateUninitialized(kInt32x4Cid, Int32x4::InstanceSize()));
   obj->ptr()->value_[0] = v0;
   obj->ptr()->value_[1] = v1;
   obj->ptr()->value_[2] = v2;
   obj->ptr()->value_[3] = v3;
   return obj;
 }
 
 
 RawFloat64x2* SnapshotReader::NewFloat64x2(double v0, double v1) {
   ASSERT(kind_ == Snapshot::kFull);
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   RawFloat64x2* obj = reinterpret_cast<RawFloat64x2*>(
       AllocateUninitialized(kFloat64x2Cid, Float64x2::InstanceSize()));
   obj->ptr()->value_[0] = v0;
   obj->ptr()->value_[1] = v1;
   return obj;
 }
 
 
 RawApiError* SnapshotReader::NewApiError() {
   ALLOC_NEW_OBJECT(ApiError);
@@ skipping 38 matching lines @@
   }
   ASSERT(SerializedHeaderTag::decode(class_header) == kObjectId);
   intptr_t class_id = SerializedHeaderData::decode(class_header);
   ASSERT(IsObjectStoreClassId(class_id));
   return class_id;
 }
 
 
 RawObject* SnapshotReader::AllocateUninitialized(intptr_t class_id,
                                                  intptr_t size) {
-  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  ASSERT(isolate()->no_safepoint_scope_depth() != 0);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
 
   // Allocate memory where all words look like smis. This is currently
   // only needed for DEBUG-mode validation in StorePointer/StoreSmi, but will
   // be essential with the upcoming deletion barrier.
   uword address =
       old_space()->TryAllocateSmiInitializedLocked(size,
                                                    PageSpace::kForceGrowth);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
@@ skipping 303 matching lines @@
   UNREACHABLE();
 }
 
 
 void SnapshotWriter::WriteObjectRef(RawObject* raw) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   RawClass* cls = class_table_->At(raw->GetClassId());
   intptr_t class_id = cls->ptr()->id_;
   ASSERT(class_id == raw->GetClassId());
   if (class_id >= kNumPredefinedCids) {
     WriteInstanceRef(raw, cls);
     return;
   }
   if (class_id == kArrayCid) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
@@ skipping 94 matching lines @@
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     ReserveHeader();
 
     // Write out the version string.
     WriteVersion();
 
     // Write out the full snapshot.
     {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
 
       // Write out all the objects in the object store of the isolate which
       // is the root set for all dart allocated objects at this point.
       SnapshotWriterVisitor visitor(this, false);
       object_store->VisitObjectPointers(&visitor);
 
       // Write out all forwarded objects.
       WriteForwardedObjects();
 
       FillHeader(kind());
@@ skipping 34 matching lines @@
 ForwardList::~ForwardList() {
   PageSpace* page_space = Isolate::Current()->heap()->old_space();
   MonitorLocker ml(page_space->tasks_lock());
   ASSERT(page_space->tasks() == 1);
   page_space->set_tasks(0);
   ml.Notify();
 }
 
 
 intptr_t ForwardList::MarkAndAddObject(RawObject* raw, SerializeState state) {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   intptr_t object_id = next_object_id();
   ASSERT(object_id <= kMaxObjectId);
   uword value = 0;
   value = SerializedHeaderTag::update(kObjectId, value);
   value = SerializedHeaderData::update(object_id, value);
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) != kObjectId);
   raw->ptr()->tags_ = value;
   Node* node = new Node(raw, tags, state);
   ASSERT(node != NULL);
   nodes_.Add(node);
   return object_id;
 }
 
 
 void ForwardList::UnmarkAll() const {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   for (intptr_t id = first_object_id(); id < next_object_id(); ++id) {
     const Node* node = NodeForObjectId(id);
     RawObject* raw = node->raw();
     raw->ptr()->tags_ = node->tags();  // Restore original tags.
   }
 }
 
 
 bool SnapshotWriter::CheckAndWritePredefinedObject(RawObject* rawobj) {
   // Check if object can be written in one of the following ways:
   // - Smi: the Smi value is written as is (last bit is not tagged).
   // - VM internal class (from VM isolate): (index of class in vm isolate | 0x3)
   // - Object that has already been written: (negative id in stream | 0x3)
 
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
 
   // First check if it is a Smi (i.e not a heap object).
   if (!rawobj->IsHeapObject()) {
     Write<int64_t>(reinterpret_cast<intptr_t>(rawobj));
     return true;
   }
 
   intptr_t cid = rawobj->GetClassId();
 
   if ((kind_ == Snapshot::kMessage) && (cid == kDoubleCid)) {
@@ skipping 81 matching lines @@
   WriteInlinedObject(raw);
 }
 
 
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
   // Now write the object out inline in the stream as follows:
   // - Object is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    serialized fields of the object
   //    ......
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
   intptr_t object_id = SerializedHeaderData::decode(tags);
   tags = forward_list_.NodeForObjectId(object_id)->tags();
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
   intptr_t class_id = cls->ptr()->id_;
 
   if (!IsSplitClassId(class_id)) {
     object_id = kOmittedObjectId;
   }
@@ skipping 370 matching lines @@
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     ReserveHeader();
 
     // Write out the version string.
     WriteVersion();
 
     // Write out the library object.
     {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
 
       // Write out the library object.
       WriteObject(lib.raw());
 
       FillHeader(kind());
       UnmarkAll();
     }
   } else {
     ThrowException(exception_type(), exception_msg());
   }
@@ skipping 13 matching lines @@
 
 
 void MessageWriter::WriteMessage(const Object& obj) {
   ASSERT(kind() == Snapshot::kMessage);
   ASSERT(isolate() != NULL);
 
   // Setup for long jump in case there is an exception while writing
   // the message.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart