Rename NoGCScope -> NoSafepointScope.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 369 matching lines @@
   }
   UNREACHABLE();
   return '\0';
 }
 
 
 void Object::InitOnce(Isolate* isolate) {
   // Should only be run by the vm isolate.
   ASSERT(isolate == Dart::vm_isolate());
 
-  // TODO(iposva): NoGCScope needs to be added here.
+  // TODO(iposva): NoSafepointScope needs to be added here.
   ASSERT(class_class() == null_);
   // Initialize the static vtable values.
   {
     Object fake_object;
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
   Heap* heap = isolate->heap();
@@ skipping 442 matching lines @@
 }
 
 
 // Make unused space in an object whose type has been transformed safe
 // for traversing during GC.
 // The unused part of the transformed object is marked as an TypedDataInt8Array
 // object.
 void Object::MakeUnusedSpaceTraversable(const Object& obj,
                                         intptr_t original_size,
                                         intptr_t used_size) {
-  ASSERT(Isolate::Current()->no_gc_scope_depth() > 0);
+  ASSERT(Isolate::Current()->no_safepoint_scope_depth() > 0);
   ASSERT(!obj.IsNull());
   ASSERT(original_size >= used_size);
   if (original_size > used_size) {
     intptr_t leftover_size = original_size - used_size;
 
     uword addr = RawObject::ToAddr(obj.raw()) + used_size;
     if (leftover_size >= TypedData::InstanceSize(0)) {
       // Update the leftover space as a TypedDataInt8Array object.
       RawTypedData* raw =
           reinterpret_cast<RawTypedData*>(RawObject::FromAddr(addr));
@@ skipping 809 matching lines @@
     const Instance& exception =
         Instance::Handle(isolate->object_store()->out_of_memory());
     Exceptions::Throw(isolate, exception);
     UNREACHABLE();
   }
   if (space == Heap::kNew) {
     isolate->class_table()->UpdateAllocatedNew(cls_id, size);
   } else {
     isolate->class_table()->UpdateAllocatedOld(cls_id, size);
   }
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   InitializeObject(address, cls_id, size);
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   ASSERT(cls_id == RawObject::ClassIdTag::decode(raw_obj->ptr()->tags_));
   return raw_obj;
 }
 
 
 class StoreBufferUpdateVisitor : public ObjectPointerVisitor {
  public:
   explicit StoreBufferUpdateVisitor(Isolate* isolate, RawObject* obj) :
@@ skipping 28 matching lines @@
 bool Object::IsNotTemporaryScopedHandle() const {
   return (IsZoneHandle() || IsReadOnlyHandle());
 }
 
 
 
 RawObject* Object::Clone(const Object& orig, Heap::Space space) {
   const Class& cls = Class::Handle(orig.clazz());
   intptr_t size = orig.raw()->Size();
   RawObject* raw_clone = Object::Allocate(cls.id(), size, space);
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   // TODO(koda): This will trip when we start allocating black.
   // Revisit code below at that point, to account for the new write barrier.
   ASSERT(!raw_clone->IsMarked());
   // Copy the body of the original into the clone.
   uword orig_addr = RawObject::ToAddr(orig.raw());
   uword clone_addr = RawObject::ToAddr(raw_clone);
   static const intptr_t kHeaderSizeInBytes = sizeof(RawObject);
   memmove(reinterpret_cast<uint8_t*>(clone_addr + kHeaderSizeInBytes),
           reinterpret_cast<uint8_t*>(orig_addr + kHeaderSizeInBytes),
           size - kHeaderSizeInBytes);
@@ skipping 101 matching lines @@
 
 
 template <class FakeObject>
 RawClass* Class::New() {
   ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::NextFieldOffset());
   COMPILE_ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
   result.set_state_bits(0);
   if (FakeObject::kClassId < kInstanceCid) {
@@ skipping 1078 matching lines @@
 
 
 template <class FakeInstance>
 RawClass* Class::New(intptr_t index) {
   ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::NextFieldOffset());
   result.set_id(index);
   result.set_state_bits(0);
   result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
@@ skipping 918 matching lines @@
     ClassFunctionsSet set(raw_ptr()->functions_hash_table_);
     REUSABLE_STRING_HANDLESCOPE(isolate);
     function ^= set.GetOrNull(FunctionName(name, &(isolate->StringHandle())));
     // No mutations.
     ASSERT(set.Release().raw() == raw_ptr()->functions_hash_table_);
     return function.IsNull() ? Function::null()
                              : CheckFunctionType(function, kind);
   }
   if (name.IsSymbol()) {
     // Quick Symbol compare.
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     for (intptr_t i = 0; i < len; i++) {
       function ^= funcs.At(i);
       if (function.name() == name.raw()) {
         return CheckFunctionType(function, kind);
       }
     }
   } else {
     REUSABLE_STRING_HANDLESCOPE(isolate);
     String& function_name = isolate->StringHandle();
     for (intptr_t i = 0; i < len; i++) {
@@ skipping 866 matching lines @@
 RawTypeArguments* TypeArguments::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TypeArguments::New: invalid len %" Pd "\n", len);
   }
   TypeArguments& result = TypeArguments::Handle();
   {
     RawObject* raw = Object::Allocate(TypeArguments::kClassId,
                                       TypeArguments::InstanceSize(len),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     // Length must be set before we start storing into the array.
     result.SetLength(len);
   }
   // The zero array should have been initialized.
   ASSERT(Object::zero_array().raw() != Array::null());
   COMPILE_ASSERT(StubCode::kNoInstantiator == 0);
   result.set_instantiations(Object::zero_array());
   return result.raw();
 }
@@ skipping 1293 matching lines @@
 bool Function::IsImplicitClosureFunction() const {
   if (!IsClosureFunction()) {
     return false;
   }
   const Function& parent = Function::Handle(parent_function());
   return (parent.implicit_closure_function() == raw());
 }
 
 
 bool Function::IsImplicitStaticClosureFunction(RawFunction* func) {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   uint32_t kind_tag = func->ptr()->kind_tag_;
   if (KindBits::decode(kind_tag) != RawFunction::kClosureFunction) {
     return false;
   }
   if (!StaticBit::decode(kind_tag)) {
     return false;
   }
   RawClosureData* data = reinterpret_cast<RawClosureData*>(func->ptr()->data_);
   RawFunction* parent_function = data->ptr()->parent_function_;
   return (parent_function->ptr()->data_ == reinterpret_cast<RawObject*>(func));
@@ skipping 1828 matching lines @@
 
   // Create and setup the token stream object.
   const ExternalTypedData& stream = ExternalTypedData::Handle(
       ExternalTypedData::New(kExternalTypedDataUint8ArrayCid,
                              data.GetStream(), data.Length(), Heap::kOld));
   stream.AddFinalizer(data.GetStream(), DataFinalizer);
   const TokenStream& result = TokenStream::Handle(New());
   result.SetPrivateKey(private_key);
   const Array& token_objects = Array::Handle(data.MakeTokenObjectsArray());
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result.SetStream(stream);
     result.SetTokenObjects(token_objects);
   }
   return result.raw();
 }
 
 
 const char* TokenStream::ToCString() const {
   return "TokenStream";
 }
@@ skipping 2522 matching lines @@
   if (size < 0 || size > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Instructions::New: invalid size %" Pd "\n", size);
   }
   Instructions& result = Instructions::Handle();
   {
     uword aligned_size = Instructions::InstanceSize(size);
     RawObject* raw = Object::Allocate(Instructions::kClassId,
                                       aligned_size,
                                       Heap::kCode);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_size(size);
   }
   return result.raw();
 }
 
 
 const char* Instructions::ToCString() const {
   return "Instructions";
 }
@@ skipping 32 matching lines @@
     FATAL1("Fatal error in PcDescriptors::New: "
            "invalid num_descriptors %" Pd "\n", num_descriptors);
   }
   PcDescriptors& result = PcDescriptors::Handle();
   {
     const intptr_t rec_size =  RawPcDescriptors::RecordSize(has_try_index);
     uword size = PcDescriptors::InstanceSize(num_descriptors, rec_size);
     RawObject* raw = Object::Allocate(PcDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(num_descriptors);
     result.SetRecordSizeInBytes(rec_size);
   }
   return result.raw();
 }
 
 
 const char* PcDescriptors::KindAsStr(RawPcDescriptors::Kind kind) {
   switch (kind) {
@@ skipping 142 matching lines @@
   uint8_t byte = raw_ptr()->data()[byte_index];
   return (byte & byte_mask);
 }
 
 
 void Stackmap::SetBit(intptr_t bit_index, bool value) const {
   ASSERT(InRange(bit_index));
   int byte_index = bit_index >> kBitsPerByteLog2;
   int bit_remainder = bit_index & (kBitsPerByte - 1);
   uint8_t byte_mask = 1U << bit_remainder;
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   uint8_t* byte_addr = UnsafeMutableNonPointer(&raw_ptr()->data()[byte_index]);
   if (value) {
     *byte_addr |= byte_mask;
   } else {
     *byte_addr &= ~byte_mask;
   }
 }
 
 
 RawStackmap* Stackmap::New(intptr_t pc_offset,
@@ skipping 11 matching lines @@
     // This should be caught before we reach here.
     FATAL1("Fatal error in Stackmap::New: invalid length %" Pd "\n",
            length);
   }
   {
     // Stackmap data objects are associated with a code object, allocate them
     // in old generation.
     RawObject* raw = Object::Allocate(Stackmap::kClassId,
                                       Stackmap::InstanceSize(length),
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(length);
   }
   // When constructing a stackmap we store the pc offset in the stackmap's
   // PC. StackmapTableBuilder::FinalizeStackmaps will replace it with the pc
   // address.
   ASSERT(pc_offset >= 0);
   result.SetPcOffset(pc_offset);
   for (intptr_t i = 0; i < length; ++i) {
     result.SetBit(i, bmap->Get(i));
@@ skipping 203 matching lines @@
     FATAL2("Fatal error in LocalVarDescriptors::New: "
            "invalid num_variables %" Pd ". Maximum is: %d\n",
            num_variables, RawLocalVarDescriptors::kMaxIndex);
   }
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
     RawObject* raw = Object::Allocate(LocalVarDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->num_entries_, num_variables);
   }
   return result.raw();
 }
 
 
 intptr_t LocalVarDescriptors::Length() const {
   return raw_ptr()->num_entries_;
 }
 
 
 intptr_t ExceptionHandlers::num_entries() const {
   return raw_ptr()->num_entries_;
 }
 
 
 void ExceptionHandlers::SetHandlerInfo(intptr_t try_index,
                                        intptr_t outer_try_index,
                                        uword handler_pc_offset,
                                        bool needs_stacktrace,
                                        bool has_catch_all) const {
   ASSERT((try_index >= 0) && (try_index < num_entries()));
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   RawExceptionHandlers::HandlerInfo* info =
       UnsafeMutableNonPointer(&raw_ptr()->data()[try_index]);
   info->outer_try_index = outer_try_index;
   // Some C compilers warn about the comparison always being true when using <=
   // due to limited range of data type.
   ASSERT((handler_pc_offset == static_cast<uword>(kMaxUint32)) ||
          (handler_pc_offset < static_cast<uword>(kMaxUint32)));
   info->handler_pc_offset = handler_pc_offset;
   info->needs_stacktrace = needs_stacktrace;
   info->has_catch_all = has_catch_all;
@@ skipping 60 matching lines @@
     FATAL1("Fatal error in ExceptionHandlers::New(): "
            "invalid num_handlers %" Pd "\n",
            num_handlers);
   }
   ExceptionHandlers& result = ExceptionHandlers::Handle();
   {
     uword size = ExceptionHandlers::InstanceSize(num_handlers);
     RawObject* raw = Object::Allocate(ExceptionHandlers::kClassId,
                                       size,
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->num_entries_, num_handlers);
   }
   const Array& handled_types_data = (num_handlers == 0) ?
       Object::empty_array() :
       Array::Handle(Array::New(num_handlers));
   result.set_handled_types_data(handled_types_data);
   return result.raw();
 }
 
@@ skipping 58 matching lines @@
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 intptr_t DeoptInfo::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 intptr_t DeoptInfo::FromIndex(intptr_t index) const {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   return *(EntryAddr(index, kFromIndex));
 }
 
 
 intptr_t DeoptInfo::Instruction(intptr_t index) const {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   return *(EntryAddr(index, kInstruction));
 }
 
 
 intptr_t DeoptInfo::FrameSize() const {
   return TranslationLength() - NumMaterializations();
 }
 
 
 intptr_t DeoptInfo::TranslationLength() const {
@@ skipping 99 matching lines @@
   if ((num_commands < 0) || (num_commands > kMaxElements)) {
     FATAL1("Fatal error in DeoptInfo::New(): invalid num_commands %" Pd "\n",
            num_commands);
   }
   DeoptInfo& result = DeoptInfo::Handle();
   {
     uword size = DeoptInfo::InstanceSize(num_commands);
     RawObject* raw = Object::Allocate(DeoptInfo::kClassId,
                                       size,
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(num_commands);
   }
   return result.raw();
 }
 
 
 void DeoptInfo::SetLength(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->length_, Smi::New(value));
 }
 
 
 void DeoptInfo::SetAt(intptr_t index,
                       intptr_t instr_kind,
                       intptr_t from_index) const {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   *(EntryAddr(index, kInstruction)) = instr_kind;
   *(EntryAddr(index, kFromIndex)) = from_index;
 }
 
 
 const char* ICData::ToCString() const {
   const char* kFormat = "ICData target:'%s' num-args: %" Pd
                         " num-checks: %" Pd "";
   const String& name = String::Handle(target_name());
   const intptr_t num_args = NumArgsTested();
@@ skipping 330 matching lines @@
   GrowableArray<intptr_t> class_ids;
   Function& target = Function::Handle();
   GetCheckAt(index, &class_ids, &target);
   return class_ids[arg_nr];
 }
 
 
 intptr_t ICData::GetReceiverClassIdAt(intptr_t index) const {
   ASSERT(index < NumberOfChecks());
   const intptr_t data_pos = index * TestEntryLength();
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   RawArray* raw_data = ic_data();
   return Smi::Value(Smi::RawCast(raw_data->ptr()->data()[data_pos]));
 }
 
 
 RawFunction* ICData::GetTargetAt(intptr_t index) const {
   const intptr_t data_pos = index * TestEntryLength() + NumArgsTested();
   ASSERT(Object::Handle(Array::Handle(ic_data()).At(data_pos)).IsFunction());
 
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   RawArray* raw_data = ic_data();
   return reinterpret_cast<RawFunction*>(raw_data->ptr()->data()[data_pos]);
 }
 
 
 void ICData::IncrementCountAt(intptr_t index, intptr_t value) const {
   ASSERT(0 <= value);
   ASSERT(value <= Smi::kMaxValue);
   SetCountAt(index, Utils::Minimum(GetCountAt(index) + value, Smi::kMaxValue));
 }
@@ skipping 179 matching lines @@
   ASSERT(!target_name.IsNull());
   ASSERT(!arguments_descriptor.IsNull());
   ASSERT(Object::icdata_class() != Class::null());
   ASSERT(num_args_tested >= 0);
   ICData& result = ICData::Handle();
   {
     // IC data objects are long living objects, allocate them in old generation.
     RawObject* raw = Object::Allocate(ICData::kClassId,
                                       ICData::InstanceSize(),
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_owner(owner);
   result.set_target_name(target_name);
   result.set_arguments_descriptor(arguments_descriptor);
   result.set_deopt_id(deopt_id);
   result.set_state_bits(0);
   result.SetNumArgsTested(num_args_tested);
   // Number of array elements in one test entry.
   intptr_t len = result.TestEntryLength();
@@ skipping 264 matching lines @@
       *deopt_flags = DeoptTable::FlagsField::decode(reason_and_flags.Value());
       return info.raw();
     }
   }
   *deopt_reason = ICData::kDeoptUnknown;
   return DeoptInfo::null();
 }
 
 
 intptr_t Code::BinarySearchInSCallTable(uword pc) const {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   const Array& table = Array::Handle(raw_ptr()->static_calls_target_table_);
   RawObject* key = reinterpret_cast<RawObject*>(Smi::New(pc - EntryPoint()));
   intptr_t imin = 0;
   intptr_t imax = table.Length() / kSCallTableEntryLength;
   while (imax >= imin) {
     const intptr_t imid = ((imax - imin) / 2) + imin;
     const intptr_t real_index = imid * kSCallTableEntryLength;
     RawObject* key_in_table = table.At(real_index);
     if (key_in_table < key) {
       imin = imid + 1;
@@ skipping 111 matching lines @@
   if (pointer_offsets_length < 0 || pointer_offsets_length > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Code::New: invalid pointer_offsets_length %" Pd "\n",
            pointer_offsets_length);
   }
   ASSERT(Object::code_class() != Class::null());
   Code& result = Code::Handle();
   {
     uword size = Code::InstanceSize(pointer_offsets_length);
     RawObject* raw = Object::Allocate(Code::kClassId, size, Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
     result.set_is_alive(false);
     result.set_comments(Comments::New(0));
     result.set_compile_timestamp(0);
     result.set_entry_patch_pc_offset(kInvalidPc);
     result.set_patch_code_pc_offset(kInvalidPc);
     result.set_lazy_deopt_pc_offset(kInvalidPc);
     result.set_pc_descriptors(Object::empty_descriptors());
@@ skipping 24 matching lines @@
   CPU::FlushICache(instrs.EntryPoint(), instrs.size());
 
   code.set_compile_timestamp(OS::GetCurrentTimeMicros());
   CodeObservers::NotifyAll(name,
                            instrs.EntryPoint(),
                            assembler->prologue_offset(),
                            instrs.size(),
                            optimized);
 
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     const ZoneGrowableArray<intptr_t>& pointer_offsets =
         assembler->GetPointerOffsets();
     ASSERT(pointer_offsets.length() == pointer_offset_count);
     ASSERT(code.pointer_offsets_length() == pointer_offsets.length());
 
     // Set pointer offsets list in Code object and resolve all handles in
     // the instruction stream to raw objects.
     for (intptr_t i = 0; i < pointer_offsets.length(); i++) {
       intptr_t offset_in_instrs = pointer_offsets[i];
       code.SetPointerOffsetAt(i, offset_in_instrs);
@@ skipping 48 matching lines @@
 
 
 // Check if object matches find condition.
 bool Code::FindRawCodeVisitor::FindObject(RawObject* obj) const {
   return RawInstructions::ContainsPC(obj, pc_);
 }
 
 
 RawCode* Code::LookupCodeInIsolate(Isolate* isolate, uword pc) {
   ASSERT((isolate == Isolate::Current()) || (isolate == Dart::vm_isolate()));
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   FindRawCodeVisitor visitor(pc);
   RawInstructions* instr;
   if (isolate->heap() == NULL) {
     return Code::null();
   }
   instr = isolate->heap()->FindObjectInCodeSpace(&visitor);
   if (instr != Instructions::null()) {
     return instr->ptr()->code_;
   }
   return Code::null();
@@ skipping 247 matching lines @@
 uword Code::GetLazyDeoptPc() const {
   return (lazy_deopt_pc_offset() != kInvalidPc)
       ? EntryPoint() + lazy_deopt_pc_offset() : 0;
 }
 
 
 RawStackmap* Code::GetStackmap(
     uint32_t pc_offset, Array* maps, Stackmap* map) const {
   // This code is used during iterating frames during a GC and hence it
   // should not in turn start a GC.
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   if (stackmaps() == Array::null()) {
     // No stack maps are present in the code object which means this
     // frame relies on tagged pointers.
     return Stackmap::null();
   }
   // A stack map is present in the code object, use the stack map to visit
   // frame slots which are marked as having objects.
   *maps = stackmaps();
   *map = Stackmap::null();
   for (intptr_t i = 0; i < maps->Length(); i++) {
@@ skipping 101 matching lines @@
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Context::New: invalid num_variables %" Pd "\n",
            num_variables);
   }
   Context& result = Context::Handle();
   {
     RawObject* raw = Object::Allocate(Context::kClassId,
                                       Context::InstanceSize(num_variables),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_num_variables(num_variables);
   }
   return result.raw();
 }
 
 
 const char* Context::ToCString() const {
   if (IsNull()) {
     return "Context (Null)";
@@ skipping 83 matching lines @@
     // This should be caught before we reach here.
     FATAL1("Fatal error in ContextScope::New: invalid num_variables %" Pd "\n",
            num_variables);
   }
   intptr_t size = ContextScope::InstanceSize(num_variables);
   ContextScope& result = ContextScope::Handle();
   {
     RawObject* raw = Object::Allocate(ContextScope::kClassId,
                                       size,
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_num_variables(num_variables);
   }
   return result.raw();
 }
 
 
 intptr_t ContextScope::TokenIndexAt(intptr_t scope_index) const {
   return Smi::Value(VariableDescAddr(scope_index)->token_pos);
 }
@@ skipping 144 matching lines @@
 void MegamorphicCache::set_filled_entry_count(intptr_t count) const {
   StoreNonPointer(&raw_ptr()->filled_entry_count_, count);
 }
 
 
 RawMegamorphicCache* MegamorphicCache::New() {
   MegamorphicCache& result = MegamorphicCache::Handle();
   { RawObject* raw = Object::Allocate(MegamorphicCache::kClassId,
                                       MegamorphicCache::InstanceSize(),
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   const intptr_t capacity = kInitialCapacity;
   const Array& buckets = Array::Handle(Array::New(kEntryLength * capacity));
   const Function& handler = Function::Handle(
       Isolate::Current()->megamorphic_cache_table()->miss_handler());
   for (intptr_t i = 0; i < capacity; ++i) {
     SetEntry(buckets, i, smi_illegal_cid(), handler);
   }
   result.set_buckets(buckets);
@@ skipping 66 matching lines @@
 
 RawSubtypeTestCache* SubtypeTestCache::New() {
   ASSERT(Object::subtypetestcache_class() != Class::null());
   SubtypeTestCache& result = SubtypeTestCache::Handle();
   {
     // SubtypeTestCache objects are long living objects, allocate them in the
     // old generation.
     RawObject* raw = Object::Allocate(SubtypeTestCache::kClassId,
                                       SubtypeTestCache::InstanceSize(),
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   const Array& cache = Array::Handle(Array::New(kTestEntryLength));
   result.set_cache(cache);
   return result.raw();
 }
 
 
 void SubtypeTestCache::set_cache(const Array& value) const {
   StorePointer(&raw_ptr()->cache_, value.raw());
 }
 
 
 intptr_t SubtypeTestCache::NumberOfChecks() const {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   // Do not count the sentinel;
   return (Smi::Value(cache()->ptr()->length_) / kTestEntryLength) - 1;
 }
 
 
 void SubtypeTestCache::AddCheck(
     intptr_t instance_class_id,
     const TypeArguments& instance_type_arguments,
     const TypeArguments& instantiator_type_arguments,
     const Bool& test_result) const {
@@ skipping 65 matching lines @@
 }
 
 
 RawApiError* ApiError::New(const String& message, Heap::Space space) {
   ASSERT(Object::api_error_class() != Class::null());
   ApiError& result = ApiError::Handle();
   {
     RawObject* raw = Object::Allocate(ApiError::kClassId,
                                       ApiError::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
 void ApiError::set_message(const String& message) const {
   StorePointer(&raw_ptr()->message_, message.raw());
 }
@@ skipping 33 matching lines @@
                                                Report::Kind kind,
                                                Heap::Space space,
                                                const char* format,
                                                va_list args) {
   ASSERT(Object::language_error_class() != Class::null());
   LanguageError& result = LanguageError::Handle();
   {
     RawObject* raw = Object::Allocate(LanguageError::kClassId,
                                       LanguageError::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_previous_error(prev_error);
   result.set_script(script);
   result.set_token_pos(token_pos);
   result.set_kind(kind);
   result.set_message(String::Handle(String::NewFormattedV(format, args)));
   return result.raw();
 }
 
 
 RawLanguageError* LanguageError::NewFormatted(const Error& prev_error,
                                               const Script& script,
                                               intptr_t token_pos,
                                               Report::Kind kind,
                                               Heap::Space space,
                                               const char* format, ...) {
   va_list args;
   va_start(args, format);
   RawLanguageError* result = LanguageError::NewFormattedV(
       prev_error, script, token_pos, kind, space, format, args);
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   va_end(args);
   return result;
 }
 
 
 RawLanguageError* LanguageError::New(const String& formatted_message,
                                      Report::Kind kind,
                                      Heap::Space space) {
   ASSERT(Object::language_error_class() != Class::null());
   LanguageError& result = LanguageError::Handle();
   {
     RawObject* raw = Object::Allocate(LanguageError::kClassId,
                                       LanguageError::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_formatted_message(formatted_message);
   result.set_kind(kind);
   return result.raw();
 }
 
 
 void LanguageError::set_previous_error(const Error& value) const {
   StorePointer(&raw_ptr()->previous_error_, value.raw());
@@ skipping 67 matching lines @@
 
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
                                                Heap::Space space) {
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
     RawObject* raw = Object::Allocate(UnhandledException::kClassId,
                                       UnhandledException::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_exception(exception);
   result.set_stacktrace(stacktrace);
   return result.raw();
 }
 
 
 RawUnhandledException* UnhandledException::New(Heap::Space space) {
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
     RawObject* raw = Object::Allocate(UnhandledException::kClassId,
                                       UnhandledException::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_exception(Object::null_instance());
   result.set_stacktrace(Stacktrace::Handle());
   return result.raw();
 }
 
 
 void UnhandledException::set_exception(const Instance& exception) const {
   StorePointer(&raw_ptr()->exception_, exception.raw());
@@ skipping 59 matching lines @@
 }
 
 
 RawUnwindError* UnwindError::New(const String& message, Heap::Space space) {
   ASSERT(Object::unwind_error_class() != Class::null());
   UnwindError& result = UnwindError::Handle();
   {
     RawObject* raw = Object::Allocate(UnwindError::kClassId,
                                       UnwindError::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
 void UnwindError::set_message(const String& message) const {
   StorePointer(&raw_ptr()->message_, message.raw());
 }
@@ skipping 45 matching lines @@
 bool Instance::CanonicalizeEquals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
 
   if (other.IsNull() || (this->clazz() != other.clazz())) {
     return false;
   }
 
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     // Raw bits compare.
     const intptr_t instance_size = Class::Handle(this->clazz()).instance_size();
     ASSERT(instance_size != 0);
     uword this_addr = reinterpret_cast<uword>(this->raw_ptr());
     uword other_addr = reinterpret_cast<uword>(other.raw_ptr());
     for (intptr_t offset = Instance::NextFieldOffset();
          offset < instance_size;
          offset += kWordSize) {
       if ((*reinterpret_cast<RawObject**>(this_addr + offset)) !=
           (*reinterpret_cast<RawObject**>(other_addr + offset))) {
@@ skipping 206 matching lines @@
     return Integer::Cast(*this).Equals(other);
   }
   if (IsDouble() && other.IsDouble()) {
     return Double::Cast(*this).CanonicalizeEquals(other);
   }
   return false;
 }
 
 
 intptr_t* Instance::NativeFieldsDataAddr() const {
-  ASSERT(Isolate::Current()->no_gc_scope_depth() > 0);
+  ASSERT(Isolate::Current()->no_safepoint_scope_depth() > 0);
   RawTypedData* native_fields =
       reinterpret_cast<RawTypedData*>(*NativeFieldsAddr());
   if (native_fields == TypedData::null()) {
     return NULL;
   }
   return reinterpret_cast<intptr_t*>(native_fields->ptr()->data());
 }
 
 
 void Instance::SetNativeField(int index, intptr_t value) const {
@@ skipping 128 matching lines @@
   if (IsNull()) {
     return "null";
   } else if (raw() == Object::sentinel().raw()) {
     return "sentinel";
   } else if (raw() == Object::transition_sentinel().raw()) {
     return "transition_sentinel";
   } else if (raw() == Object::unknown_constant().raw()) {
     return "unknown_constant";
   } else if (raw() == Object::non_constant().raw()) {
     return "non_constant";
-  } else if (Isolate::Current()->no_gc_scope_depth() > 0) {
+  } else if (Isolate::Current()->no_safepoint_scope_depth() > 0) {
     // Can occur when running disassembler.
     return "Instance";
   } else {
     if (IsClosure()) {
       return Closure::ToCString(*this);
     }
     const char* kFormat = "Instance of '%s'";
     const Class& cls = Class::Handle(clazz());
     TypeArguments& type_arguments = TypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
@@ skipping 2385 matching lines @@
 
 RawMint* Mint::New(int64_t val, Heap::Space space) {
   // Do not allocate a Mint if Smi would do.
   ASSERT(!Smi::IsValid(val));
   ASSERT(Isolate::Current()->object_store()->mint_class() != Class::null());
   Mint& result = Mint::Handle();
   {
     RawObject* raw = Object::Allocate(Mint::kClassId,
                                       Mint::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(val);
   return result.raw();
 }
 
 
 RawMint* Mint::NewCanonical(int64_t value) {
   // Do not allocate a Mint if Smi would do.
   ASSERT(!Smi::IsValid(value));
@@ skipping 129 matching lines @@
 }
 
 
 RawDouble* Double::New(double d, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->double_class() != Class::null());
   Double& result = Double::Handle();
   {
     RawObject* raw = Object::Allocate(Double::kClassId,
                                       Double::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(d);
   return result.raw();
 }
 
 
 RawDouble* Double::New(const String& str, Heap::Space space) {
   double double_value;
   if (!CStringToDouble(str.ToCString(), str.Length(), &double_value)) {
@@ skipping 183 matching lines @@
 
 
 RawBigint* Bigint::New(Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->object_store()->bigint_class() != Class::null());
   Bigint& result = Bigint::Handle(isolate);
   {
     RawObject* raw = Object::Allocate(Bigint::kClassId,
                                       Bigint::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.SetNeg(false);
   result.SetUsed(0);
   result.set_digits(
       TypedData::Handle(isolate, TypedData::EmptyUint32Array(isolate)));
   return result.raw();
 }
 
 
 RawBigint* Bigint::New(bool neg, intptr_t used, const TypedData& digits,
                        Heap::Space space) {
   ASSERT((used == 0) ||
          (!digits.IsNull() && (digits.Length() >= (used + (used & 1)))));
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->object_store()->bigint_class() != Class::null());
   Bigint& result = Bigint::Handle(isolate);
   {
     RawObject* raw = Object::Allocate(Bigint::kClassId,
                                       Bigint::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   // Clamp the digits array.
   while ((used > 0) && (digits.GetUint32((used - 1) << 2) == 0)) {
     --used;
   }
   if (used > 0) {
     if ((used & 1) != 0) {
       // Set leading zero for 64-bit processing of digit pairs.
       digits.SetUint32(used << 2, 0);
@@ skipping 636 matching lines @@
 
 
 void StringHasher::Add(const String& str, intptr_t begin_index, intptr_t len) {
   ASSERT(begin_index >= 0);
   ASSERT(len >= 0);
   ASSERT((begin_index + len) <= str.Length());
   if (len == 0) {
     return;
   }
   if (str.IsOneByteString()) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     uint8_t* str_addr = OneByteString::CharAddr(str, begin_index);
     for (intptr_t i = 0; i < len; i++) {
       Add(*str_addr);
       str_addr++;
     }
   } else {
     String::CodePointIterator it(str, begin_index, len);
     while (it.Next()) {
       Add(it.Current());
     }
@@ skipping 257 matching lines @@
 
 
 RawString* String::FromUTF8(const uint8_t* utf8_array,
                             intptr_t array_len,
                             Heap::Space space) {
   Utf8::Type type;
   intptr_t len = Utf8::CodeUnitCount(utf8_array, array_len, &type);
   if (type == Utf8::kLatin1) {
     const String& strobj = String::Handle(OneByteString::New(len, space));
     if (len > 0) {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       Utf8::DecodeToLatin1(utf8_array, array_len,
                            OneByteString::CharAddr(strobj, 0), len);
     }
     return strobj.raw();
   }
   ASSERT((type == Utf8::kBMP) || (type == Utf8::kSupplementary));
   const String& strobj = String::Handle(TwoByteString::New(len, space));
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   Utf8::DecodeToUTF16(utf8_array, array_len,
                       TwoByteString::CharAddr(strobj, 0), len);
   return strobj.raw();
 }
 
 
 RawString* String::FromLatin1(const uint8_t* latin1_array,
                               intptr_t array_len,
                               Heap::Space space) {
   return OneByteString::New(latin1_array, array_len, space);
@@ skipping 74 matching lines @@
 }
 
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const uint8_t* characters,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     if (len > 0) {
       memmove(OneByteString::CharAddr(dst, dst_offset),
               characters,
               len);
     }
   } else if (dst.IsTwoByteString()) {
     for (intptr_t i = 0; i < len; ++i) {
       *TwoByteString::CharAddr(dst, i + dst_offset) = characters[i];
     }
   }
 }
 
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const uint16_t* utf16_array,
                   intptr_t array_len) {
   ASSERT(dst_offset >= 0);
   ASSERT(array_len >= 0);
   ASSERT(array_len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     for (intptr_t i = 0; i < array_len; ++i) {
       ASSERT(Utf::IsLatin1(utf16_array[i]));
       *OneByteString::CharAddr(dst, i + dst_offset) = utf16_array[i];
     }
   } else {
     ASSERT(dst.IsTwoByteString());
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     if (array_len > 0) {
       memmove(TwoByteString::CharAddr(dst, dst_offset),
               utf16_array,
               array_len * 2);
     }
   }
 }
 
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const String& src, intptr_t src_offset,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(src_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   ASSERT(len <= (src.Length() - src_offset));
   if (len > 0) {
     intptr_t char_size = src.CharSize();
     if (char_size == kOneByteChar) {
       if (src.IsOneByteString()) {
-        NoGCScope no_gc;
+        NoSafepointScope no_safepoint;
         String::Copy(dst,
                      dst_offset,
                      OneByteString::CharAddr(src, src_offset),
                      len);
       } else {
         ASSERT(src.IsExternalOneByteString());
-        NoGCScope no_gc;
+        NoSafepointScope no_safepoint;
         String::Copy(dst,
                      dst_offset,
                      ExternalOneByteString::CharAddr(src, src_offset),
                      len);
       }
     } else {
       ASSERT(char_size == kTwoByteChar);
       if (src.IsTwoByteString()) {
-        NoGCScope no_gc;
+        NoSafepointScope no_safepoint;
         String::Copy(dst,
                      dst_offset,
                      TwoByteString::CharAddr(src, src_offset),
                      len);
       } else {
         ASSERT(src.IsExternalTwoByteString());
-        NoGCScope no_gc;
+        NoSafepointScope no_safepoint;
         String::Copy(dst,
                      dst_offset,
                      ExternalTwoByteString::CharAddr(src, src_offset),
                      len);
       }
     }
   }
 }
 
 
@@ skipping 161 matching lines @@
     }
   }
   return FromUTF8(utf8, utf8_len);
 }
 
 
 RawString* String::NewFormatted(const char* format, ...) {
   va_list args;
   va_start(args, format);
   RawString* result = NewFormattedV(format, args);
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   va_end(args);
   return result;
 }
 
 
 RawString* String::NewFormattedV(const char* format, va_list args) {
   va_list args_copy;
   va_copy(args_copy, args);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args_copy);
   va_end(args_copy);
@@ skipping 106 matching lines @@
 
 const char* String::ToCString() const {
   if (IsOneByteString()) {
     // Quick conversion if OneByteString contains only ASCII characters.
     intptr_t len = Length();
     if (len == 0) {
       return "";
     }
     Zone* zone = Isolate::Current()->current_zone();
     uint8_t* result = zone->Alloc<uint8_t>(len + 1);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     const uint8_t* original_str = OneByteString::CharAddr(*this, 0);
     for (intptr_t i = 0; i < len; i++) {
       if (original_str[i] <= Utf8::kMaxOneByteChar) {
         result[i] = original_str[i];
       } else {
         len = -1;
         break;
       }
     }
     if (len > 0) {
@@ skipping 63 matching lines @@
 
 
 RawString* String::MakeExternal(void* array,
                                 intptr_t length,
                                 void* peer,
                                 Dart_PeerFinalizer cback) const {
   String& result = String::Handle();
   void* external_data;
   Dart_WeakPersistentHandleFinalizer finalizer;
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     ASSERT(array != NULL);
     intptr_t str_length = this->Length();
     ASSERT(length >= (str_length * this->CharSize()));
     intptr_t class_id = raw()->GetClassId();
 
     ASSERT(!InVMHeap());
     if (class_id == kOneByteStringCid) {
       intptr_t used_size = ExternalOneByteString::InstanceSize();
       intptr_t original_size = OneByteString::InstanceSize(str_length);
       ASSERT(original_size >= used_size);
@@ skipping 60 matching lines @@
       const uint16_t* ext_array = reinterpret_cast<const uint16_t*>(array);
       ExternalStringData<uint16_t>* ext_data = new ExternalStringData<uint16_t>(
           ext_array, peer, cback);
       ASSERT(result.Length() == str_length);
       ASSERT(!result.HasHash() ||
              (result.Hash() == String::Hash(ext_array, str_length)));
       ExternalTwoByteString::SetExternalData(result, ext_data);
       external_data = ext_data;
       finalizer = ExternalTwoByteString::Finalize;
     }
-  }  // NoGCScope
+  }  // NoSafepointScope
   AddFinalizer(result, external_data, finalizer);
   return this->raw();
 }
 
 
 RawString* String::Transform(int32_t (*mapping)(int32_t ch),
                              const String& str,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   bool has_mapping = false;
@@ skipping 29 matching lines @@
   return Transform(CaseMapping::ToLower, str, space);
 }
 
 bool String::ParseDouble(const String& str,
                          intptr_t start, intptr_t end,
                          double* result) {
   ASSERT(0 <= start);
   ASSERT(start <= end);
   ASSERT(end <= str.Length());
   intptr_t length = end - start;
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   const uint8_t* startChar;
   if (str.IsOneByteString()) {
     startChar = OneByteString::CharAddr(str, start);
   } else if (str.IsExternalOneByteString()) {
     startChar = ExternalOneByteString::CharAddr(str, start);
   } else {
     uint8_t* chars = Isolate::Current()->current_zone()->Alloc<uint8_t>(length);
     const Scanner::CharAtFunc char_at = str.CharAtFunc();
     for (intptr_t i = 0; i < length; i++) {
       int32_t ch = char_at(str, start + i);
@@ skipping 77 matching lines @@
                                                                          str2);\
   }                                                                            \
   UNREACHABLE();                                                               \
 
 
 bool String::EqualsIgnoringPrivateKey(const String& str1,
                                       const String& str2) {
   if (str1.raw() == str2.raw()) {
     return true;  // Both handles point to the same raw instance.
   }
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   intptr_t str1_class_id = str1.raw()->GetClassId();
   intptr_t str2_class_id = str2.raw()->GetClassId();
   switch (str1_class_id) {
     case kOneByteStringCid :
       EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, OneByteString, str1, str2);
       break;
     case kTwoByteStringCid :
       EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, TwoByteString, str1, str2);
       break;
     case kExternalOneByteStringCid :
@@ skipping 103 matching lines @@
           (Isolate::Current()->object_store()->one_byte_string_class() !=
            Class::null())));
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in OneByteString::New: invalid len %" Pd "\n", len);
   }
   {
     RawObject* raw = Object::Allocate(OneByteString::kClassId,
                                       OneByteString::InstanceSize(len),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     RawOneByteString* result = reinterpret_cast<RawOneByteString*>(raw);
     result->StoreSmi(&(result->ptr()->length_), Smi::New(len));
     result->StoreSmi(&(result->ptr()->hash_), Smi::New(0));
     return result;
   }
 }
 
 
 RawOneByteString* OneByteString::New(const uint8_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
   if (len > 0) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     memmove(CharAddr(result, 0), characters, len);
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const uint16_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   for (intptr_t i = 0; i < len; ++i) {
     ASSERT(Utf::IsLatin1(characters[i]));
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const int32_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   for (intptr_t i = 0; i < len; ++i) {
     ASSERT(Utf::IsLatin1(characters[i]));
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const String& str,
                                      Heap::Space space) {
   intptr_t len = str.Length();
   const String& result = String::Handle(OneByteString::New(len, space));
   String::Copy(result, 0, str, 0, len);
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const String& other_one_byte_string,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(other_len, space));
   ASSERT(other_one_byte_string.IsOneByteString());
   if (other_len > 0) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     memmove(OneByteString::CharAddr(result, 0),
             OneByteString::CharAddr(other_one_byte_string, other_start_index),
             other_len);
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const TypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(other_len, space));
   ASSERT(other_typed_data.ElementSizeInBytes() == 1);
   if (other_len > 0) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     memmove(OneByteString::CharAddr(result, 0),
             other_typed_data.DataAddr(other_start_index),
             other_len);
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const ExternalTypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(other_len, space));
   ASSERT(other_typed_data.ElementSizeInBytes() == 1);
   if (other_len > 0) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     memmove(OneByteString::CharAddr(result, 0),
             other_typed_data.DataAddr(other_start_index),
             other_len);
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::Concat(const String& str1,
                                         const String& str2,
@@ skipping 29 matching lines @@
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
   const String& result = String::Handle(OneByteString::New(len, space));
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   for (intptr_t i = 0; i < len; ++i) {
     int32_t ch = mapping(str.CharAt(i));
     ASSERT(Utf::IsLatin1(ch));
     *CharAddr(result, i) = ch;
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::SubStringUnchecked(const String& str,
                                                     intptr_t begin_index,
                                                     intptr_t length,
                                                     Heap::Space space) {
   ASSERT(!str.IsNull() && str.IsOneByteString());
   ASSERT(begin_index >= 0);
   ASSERT(length >= 0);
   if (begin_index <= str.Length() && length == 0) {
     return OneByteString::raw(Symbols::Empty());
   }
   ASSERT(begin_index < str.Length());
   RawOneByteString* result = OneByteString::New(length, space);
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   if (length > 0) {
     uint8_t* dest = &result->ptr()->data()[0];
     const uint8_t* src =  &raw_ptr(str)->data()[begin_index];
     memmove(dest, src, length);
   }
   return result;
 }
 
 
 void OneByteString::SetPeer(const String& str,
@@ skipping 53 matching lines @@
   ASSERT(Isolate::Current()->object_store()->two_byte_string_class());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TwoByteString::New: invalid len %" Pd "\n", len);
   }
   String& result = String::Handle();
   {
     RawObject* raw = Object::Allocate(TwoByteString::kClassId,
                                       TwoByteString::InstanceSize(len),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::New(const uint16_t* utf16_array,
                                      intptr_t array_len,
                                      Heap::Space space) {
   ASSERT(array_len > 0);
   const String& result = String::Handle(TwoByteString::New(array_len, space));
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     memmove(CharAddr(result, 0), utf16_array, (array_len * 2));
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::New(intptr_t utf16_len,
                                      const int32_t* utf32_array,
                                      intptr_t array_len,
                                      Heap::Space space) {
   ASSERT((array_len > 0) && (utf16_len >= array_len));
   const String& result = String::Handle(TwoByteString::New(utf16_len, space));
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     intptr_t j = 0;
     for (intptr_t i = 0; i < array_len; ++i) {
       if (Utf::IsSupplementary(utf32_array[i])) {
         ASSERT(j < (utf16_len - 1));
         Utf16::Encode(utf32_array[i], CharAddr(result, j));
         j += 2;
       } else {
         ASSERT(j < utf16_len);
         *CharAddr(result, j) = utf32_array[i];
         j += 1;
@@ skipping 12 matching lines @@
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::New(const TypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(TwoByteString::New(other_len, space));
   if (other_len > 0) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     memmove(TwoByteString::CharAddr(result, 0),
             other_typed_data.DataAddr(other_start_index),
             other_len * sizeof(uint16_t));
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::New(const ExternalTypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(TwoByteString::New(other_len, space));
   if (other_len > 0) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     memmove(TwoByteString::CharAddr(result, 0),
             other_typed_data.DataAddr(other_start_index),
             other_len * sizeof(uint16_t));
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::Concat(const String& str1,
                                         const String& str2,
@@ skipping 31 matching lines @@
 
 
 RawTwoByteString* TwoByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
   const String& result = String::Handle(TwoByteString::New(len, space));
   String::CodePointIterator it(str);
   intptr_t i = 0;
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   while (it.Next()) {
     int32_t src = it.Current();
     int32_t dst = mapping(src);
     ASSERT(dst >= 0 && dst <= 0x10FFFF);
     intptr_t len = Utf16::Length(dst);
     if (len == 1) {
       *CharAddr(result, i) = dst;
     } else {
       ASSERT(len == 2);
       Utf16::Encode(dst, CharAddr(result, i));
@@ skipping 36 matching lines @@
     FATAL1("Fatal error in ExternalOneByteString::New: invalid len %" Pd "\n",
            len);
   }
   String& result = String::Handle();
   ExternalStringData<uint8_t>* external_data =
       new ExternalStringData<uint8_t>(data, peer, callback);
   {
     RawObject* raw = Object::Allocate(ExternalOneByteString::kClassId,
                                       ExternalOneByteString::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     SetExternalData(result, external_data);
   }
   AddFinalizer(result, external_data, ExternalOneByteString::Finalize);
   return ExternalOneByteString::raw(result);
 }
 
 
@@ skipping 17 matching lines @@
     FATAL1("Fatal error in ExternalTwoByteString::New: invalid len %" Pd "\n",
            len);
   }
   String& result = String::Handle();
   ExternalStringData<uint16_t>* external_data =
       new ExternalStringData<uint16_t>(data, peer, callback);
   {
     RawObject* raw = Object::Allocate(ExternalTwoByteString::kClassId,
                                       ExternalTwoByteString::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     SetExternalData(result, external_data);
   }
   AddFinalizer(result, external_data, ExternalTwoByteString::Finalize);
   return ExternalTwoByteString::raw(result);
 }
 
 
 void ExternalTwoByteString::Finalize(void* isolate_callback_data,
                                      Dart_WeakPersistentHandle handle,
                                      void* peer) {
   delete reinterpret_cast<ExternalStringData<uint16_t>*>(peer);
 }
 
 
 RawBool* Bool::New(bool value) {
   ASSERT(Isolate::Current()->object_store()->bool_class() != Class::null());
   Bool& result = Bool::Handle();
   {
     // Since the two boolean instances are singletons we allocate them straight
     // in the old generation.
     RawObject* raw = Object::Allocate(Bool::kClassId,
                                       Bool::InstanceSize(),
                                       Heap::kOld);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(value);
   result.SetCanonical();
   return result.raw();
 }
 
 
 const char* Bool::ToCString() const {
   return value() ? "true" : "false";
@@ skipping 56 matching lines @@
 RawArray* Array::New(intptr_t class_id, intptr_t len, Heap::Space space) {
   if ((len < 0) || (len > Array::kMaxElements)) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Array::New: invalid len %" Pd "\n", len);
   }
   {
     RawArray* raw = reinterpret_cast<RawArray*>(
         Object::Allocate(class_id,
                          Array::InstanceSize(len),
                          space));
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     raw->StoreSmi(&(raw->ptr()->length_), Smi::New(len));
     VerifiedMemory::Accept(reinterpret_cast<uword>(raw->ptr()),
                            Array::InstanceSize(len));
     return raw;
   }
 }
 
 
 RawArray* Array::Slice(intptr_t start,
                        intptr_t count,
                        bool with_type_argument) const {
   // TODO(vegorov) introduce an array allocation method that fills newly
   // allocated array with values from the given source array instead of
   // null-initializing all elements.
   Array& dest = Array::Handle(Array::New(count));
   dest.StorePointers(dest.ObjectAddr(0), ObjectAddr(start), count);
 
   if (with_type_argument) {
     dest.SetTypeArguments(TypeArguments::Handle(GetTypeArguments()));
   }
 
   return dest.raw();
 }
 
 
 void Array::MakeImmutable() const {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   uword tags = raw_ptr()->tags_;
   uword old_tags;
   do {
     old_tags = tags;
     uword new_tags = RawObject::ClassIdTag::update(kImmutableArrayCid,
                                                    old_tags);
     tags = CompareAndSwapTags(old_tags, new_tags);
   } while (tags != old_tags);
 }
 
@@ skipping 67 matching lines @@
     // This is a raw List (as in no type arguments), so we can return the
     // simple empty array.
     return Object::empty_array().raw();
   }
   intptr_t capacity_len = growable_array.Capacity();
   Isolate* isolate = Isolate::Current();
   const Array& array = Array::Handle(isolate, growable_array.data());
   array.SetTypeArguments(type_arguments);
   intptr_t capacity_size = Array::InstanceSize(capacity_len);
   intptr_t used_size = Array::InstanceSize(used_len);
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
 
   // If there is any left over space fill it with either an Array object or
   // just a plain object (depending on the amount of left over space) so
   // that it can be traversed over successfully during garbage collection.
   Object::MakeUnusedSpaceTraversable(array, capacity_size, used_size);
 
   // Update the size in the header field and length of the array object.
   uword tags = array.raw_ptr()->tags_;
   ASSERT(kArrayCid == RawObject::ClassIdTag::decode(tags));
   uword old_tags;
@@ skipping 147 matching lines @@
 
 RawGrowableObjectArray* GrowableObjectArray::New(const Array& array,
                                                  Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->growable_object_array_class()
          != Class::null());
   GrowableObjectArray& result = GrowableObjectArray::Handle();
   {
     RawObject* raw = Object::Allocate(GrowableObjectArray::kClassId,
                                       GrowableObjectArray::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(0);
     result.SetData(array);
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   if (IsNull()) {
@@ skipping 82 matching lines @@
     SetModified();
   }
   StorePointer(&raw_ptr()->data_, map.Release().raw());
 }
 
 
 RawObject* LinkedHashMap::LookUp(const Object& key) const {
   ASSERT(!IsNull());
   EnumIndexDefaultMap map(data());
   {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     RawObject* result = map.GetOrNull(key);
     ASSERT(map.Release().raw() == data());
     return result;
   }
 }
 
 
 bool LinkedHashMap::Contains(const Object& key) const {
   ASSERT(!IsNull());
   EnumIndexDefaultMap map(data());
@@ skipping 58 matching lines @@
          != Class::null());
   static const intptr_t kInitialCapacity = 4;
   const Array& data =
       Array::Handle(HashTables::New<EnumIndexDefaultMap>(kInitialCapacity,
                                                          space));
   LinkedHashMap& result = LinkedHashMap::Handle();
   {
     RawObject* raw = Object::Allocate(LinkedHashMap::kClassId,
                                       LinkedHashMap::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetData(data);
     result.SetModified();
   }
   return result.raw();
 }
 
 
 const char* LinkedHashMap::ToCString() const {
   // TODO(koda): Print key/value pairs.
   return "_LinkedHashMap";
 }
 
 
 void LinkedHashMap::PrintJSONImpl(JSONStream* stream, bool ref) const {
   // TODO(koda): Print key/value pairs.
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawFloat32x4* Float32x4::New(float v0, float v1, float v2, float v3,
                              Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
          Class::null());
   Float32x4& result = Float32x4::Handle();
   {
     RawObject* raw = Object::Allocate(Float32x4::kClassId,
                                       Float32x4::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_x(v0);
   result.set_y(v1);
   result.set_z(v2);
   result.set_w(v3);
   return result.raw();
 }
 
 
 RawFloat32x4* Float32x4::New(simd128_value_t value, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
          Class::null());
   Float32x4& result = Float32x4::Handle();
   {
     RawObject* raw = Object::Allocate(Float32x4::kClassId,
                                       Float32x4::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
 simd128_value_t Float32x4::value() const {
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
@@ skipping 65 matching lines @@
 
 RawInt32x4* Int32x4::New(int32_t v0, int32_t v1, int32_t v2, int32_t v3,
                          Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->int32x4_class() !=
          Class::null());
   Int32x4& result = Int32x4::Handle();
   {
     RawObject* raw = Object::Allocate(Int32x4::kClassId,
                                       Int32x4::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_x(v0);
   result.set_y(v1);
   result.set_z(v2);
   result.set_w(v3);
   return result.raw();
 }
 
 
 RawInt32x4* Int32x4::New(simd128_value_t value, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->int32x4_class() !=
          Class::null());
   Int32x4& result = Int32x4::Handle();
   {
     RawObject* raw = Object::Allocate(Int32x4::kClassId,
                                       Int32x4::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
 void Int32x4::set_x(int32_t value) const {
   StoreNonPointer(&raw_ptr()->value_[0], value);
 }
@@ skipping 64 matching lines @@
 
 
 RawFloat64x2* Float64x2::New(double value0, double value1, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float64x2_class() !=
          Class::null());
   Float64x2& result = Float64x2::Handle();
   {
     RawObject* raw = Object::Allocate(Float64x2::kClassId,
                                       Float64x2::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_x(value0);
   result.set_y(value1);
   return result.raw();
 }
 
 
 RawFloat64x2* Float64x2::New(simd128_value_t value, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float64x2_class() !=
          Class::null());
   Float64x2& result = Float64x2::Handle();
   {
     RawObject* raw = Object::Allocate(Float64x2::kClassId,
                                       Float64x2::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
 double Float64x2::x() const {
   return raw_ptr()->value_[0];
 }
@@ skipping 72 matching lines @@
   const TypedData& other_typed_data = TypedData::Cast(other);
 
   if (this->ElementType() != other_typed_data.ElementType()) {
     return false;
   }
 
   const intptr_t len = this->LengthInBytes();
   if (len != other_typed_data.LengthInBytes()) {
     return false;
   }
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   return (len == 0) ||
       (memcmp(DataAddr(0), other_typed_data.DataAddr(0), len) == 0);
 }
 
 
 RawTypedData* TypedData::New(intptr_t class_id,
                              intptr_t len,
                              Heap::Space space) {
   if (len < 0 || len > TypedData::MaxElements(class_id)) {
     FATAL1("Fatal error in TypedData::New: invalid len %" Pd "\n", len);
   }
   TypedData& result = TypedData::Handle();
   {
     const intptr_t lengthInBytes = len * ElementSizeInBytes(class_id);
     RawObject* raw = Object::Allocate(class_id,
                                       TypedData::InstanceSize(lengthInBytes),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     if (len > 0) {
       memset(result.DataAddr(0), 0, lengthInBytes);
     }
   }
   return result.raw();
 }
 
 
@@ skipping 29 matching lines @@
 
 RawExternalTypedData* ExternalTypedData::New(intptr_t class_id,
                                              uint8_t* data,
                                              intptr_t len,
                                              Heap::Space space) {
   ExternalTypedData& result = ExternalTypedData::Handle();
   {
     RawObject* raw = Object::Allocate(class_id,
                                       ExternalTypedData::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetData(data);
   }
   return result.raw();
 }
 
 
 const char* ExternalTypedData::ToCString() const {
   return "ExternalTypedData";
 }
 
 
 void ExternalTypedData::PrintJSONImpl(JSONStream* stream,
                                       bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawCapability* Capability::New(uint64_t id, Heap::Space space) {
   Capability& result = Capability::Handle();
   {
     RawObject* raw = Object::Allocate(Capability::kClassId,
                                       Capability::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->id_, id);
   }
   return result.raw();
 }
 
 
 const char* Capability::ToCString() const {
   return "Capability";
 }
 
 
 void Capability::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawReceivePort* ReceivePort::New(Dart_Port id,
                                  bool is_control_port,
                                  Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   const SendPort& send_port =
       SendPort::Handle(isolate, SendPort::New(id, isolate->origin_id()));
 
   ReceivePort& result = ReceivePort::Handle(isolate);
   {
     RawObject* raw = Object::Allocate(ReceivePort::kClassId,
                                       ReceivePort::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.StorePointer(&result.raw_ptr()->send_port_, send_port.raw());
   }
   if (is_control_port) {
     PortMap::SetPortState(id, PortMap::kControlPort);
   } else {
     PortMap::SetPortState(id, PortMap::kLivePort);
   }
   return result.raw();
 }
@@ skipping 15 matching lines @@
 
 
 RawSendPort* SendPort::New(Dart_Port id,
                            Dart_Port origin_id,
                            Heap::Space space) {
   SendPort& result = SendPort::Handle();
   {
     RawObject* raw = Object::Allocate(SendPort::kClassId,
                                       SendPort::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->id_, id);
     result.StoreNonPointer(&result.raw_ptr()->origin_id_, origin_id);
   }
   return result.raw();
 }
 
 
 const char* SendPort::ToCString() const {
   return "SendPort";
@@ skipping 20 matching lines @@
 
 
 RawInstance* Closure::New(const Function& function,
                           const Context& context,
                           Heap::Space space) {
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(cls.instance_size() == Closure::InstanceSize());
   Instance& result = Instance::Handle();
   {
     RawObject* raw = Object::Allocate(cls.id(), Closure::InstanceSize(), space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   Closure::set_function(result, function);
   Closure::set_context(result, context);
   return result.raw();
 }
 
 
 intptr_t Stacktrace::Length() const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
@@ skipping 54 matching lines @@
 
 
 RawStacktrace* Stacktrace::New(const Array& code_array,
                                const Array& pc_offset_array,
                                Heap::Space space) {
   Stacktrace& result = Stacktrace::Handle();
   {
     RawObject* raw = Object::Allocate(Stacktrace::kClassId,
                                       Stacktrace::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_code_array(code_array);
   result.set_pc_offset_array(pc_offset_array);
   result.set_expand_inlined(true);  // default.
   return result.raw();
 }
 
 
 RawString* Stacktrace::FullStacktrace() const {
@@ skipping 151 matching lines @@
 RawJSRegExp* JSRegExp::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in JSRegexp::New: invalid len %" Pd "\n", len);
   }
   JSRegExp& result = JSRegExp::Handle();
   {
     RawObject* raw = Object::Allocate(JSRegExp::kClassId,
                                       JSRegExp::InstanceSize(len),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_type(kUnitialized);
     result.set_flags(0);
     result.SetLength(len);
   }
   return result.raw();
 }
 
 
 void* JSRegExp::GetDataStartAddress() const {
@@ skipping 136 matching lines @@
 }
 
 
 RawMirrorReference* MirrorReference::New(const Object& referent,
                                          Heap::Space space) {
   MirrorReference& result = MirrorReference::Handle();
   {
     RawObject* raw = Object::Allocate(MirrorReference::kClassId,
                                       MirrorReference::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_referent(referent);
   return result.raw();
 }
 
 
 const char* MirrorReference::ToCString() const {
   return "_MirrorReference";
 }
@@ skipping 38 matching lines @@
                              UserTags::kMaxUserTags));
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, error);
     Exceptions::ThrowByType(Exceptions::kUnsupported, args);
   }
   // No tag with label exists, create and register with isolate tag table.
   {
     RawObject* raw = Object::Allocate(UserTag::kClassId,
                                       UserTag::InstanceSize(),
                                       space);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_label(label);
   AddTagToIsolate(isolate, result);
   return result.raw();
 }
 
 
 RawUserTag* UserTag::DefaultTag() {
   Isolate* isolate = Isolate::Current();
@@ skipping 84 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart