Rename NoGCScope -> NoSafepointScope.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 641 matching lines @@
 
   // Needs two template arguments to allow assigning enums to fixed-size ints.
   template<typename FieldType, typename ValueType>
   void StoreNonPointer(const FieldType* addr, ValueType value) const {
     // Can't use Contains, as it uses tags_, which is set through this method.
     ASSERT(reinterpret_cast<uword>(addr) >= RawObject::ToAddr(raw()));
     *const_cast<FieldType*>(addr) = value;
   }
 
   // Provides non-const access to non-pointer fields within the object. Such
-  // access does not need a write barrier, but it is *not* GC-safe (since the
-  // object might move), hence must be fully contained within a NoGCScope.
+  // access does not need a write barrier, but it is *not* GC-safe, since the
+  // object might move, hence must be fully contained within a NoSafepointScope.
   template<typename FieldType>
   FieldType* UnsafeMutableNonPointer(const FieldType* addr) const {
     // Allow pointers at the end of variable-length data, and disallow pointers
     // within the header word.
     ASSERT(Contains(reinterpret_cast<uword>(addr) - 1) &&
            Contains(reinterpret_cast<uword>(addr) - kWordSize));
-    // At least check that there is a NoGCScope, and hope it's big enough.
-    ASSERT(Isolate::Current()->no_gc_scope_depth() > 0);
+    // At least check that there is a NoSafepointScope and hope it's big enough.
+    ASSERT(Isolate::Current()->no_safepoint_scope_depth() > 0);
     return const_cast<FieldType*>(addr);
   }
 
   // Fail at link time if StoreNonPointer or UnsafeMutableNonPointer is
   // instantiated with an object pointer type.
 #define STORE_NON_POINTER_ILLEGAL_TYPE(type)                                   \
   template<typename ValueType>                                                 \
   void StoreNonPointer(Raw##type* const* addr, ValueType value) const {        \
     UnimplementedMethod();                                                     \
   }                                                                            \
@@ skipping 2592 matching lines @@
 
 
 class PcDescriptors : public Object {
  public:
   void AddDescriptor(intptr_t index,
                      uword pc_offset,
                      RawPcDescriptors::Kind kind,
                      int64_t deopt_id,
                      int64_t token_pos,  // Or deopt reason.
                      intptr_t try_index) const {  // Or deopt index.
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     RawPcDescriptors::PcDescriptorRec* rec = recAt(index);
     rec->set_pc_offset(pc_offset);
     rec->set_kind(kind);
     ASSERT(Utils::IsInt(32, deopt_id));
     rec->set_deopt_id(static_cast<int32_t>(deopt_id));
     ASSERT(Utils::IsInt(32, token_pos));
     rec->set_token_pos(static_cast<int32_t>(token_pos),
         RecordSizeInBytes() == RawPcDescriptors::kCompressedRecSize);
     ASSERT(Utils::IsInt(16, try_index));
     rec->set_try_index(try_index);
@@ skipping 43 matching lines @@
       if (HasNext()) {
         current_ix_ = next_ix_++;
         MoveToMatching();
         return true;
       } else {
         return false;
       }
     }
 
     uword PcOffset() const {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       return descriptors_.recAt(current_ix_)->pc_offset();
     }
     intptr_t DeoptId() const {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       return descriptors_.recAt(current_ix_)->deopt_id();
     }
     intptr_t TokenPos() const {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       return descriptors_.recAt(current_ix_)->token_pos();
     }
     intptr_t TryIndex() const {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       return descriptors_.recAt(current_ix_)->try_index();
     }
     RawPcDescriptors::Kind Kind() const {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       return descriptors_.recAt(current_ix_)->kind();
     }
 
    private:
     friend class PcDescriptors;
 
     bool HasNext() const { return next_ix_ < descriptors_.Length(); }
 
     // For nested iterations, starting at element after.
     explicit Iterator(const Iterator& iter)
         : ValueObject(),
           descriptors_(iter.descriptors_),
           kind_mask_(iter.kind_mask_),
           next_ix_(iter.next_ix_),
           current_ix_(iter.current_ix_) {}
 
     // Moves to record that matches kind_mask_.
     void MoveToMatching() {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       while (next_ix_ < descriptors_.Length()) {
         const RawPcDescriptors::PcDescriptorRec& rec =
             *descriptors_.recAt(next_ix_);
         if ((rec.kind() & kind_mask_) != 0) {
           return;  // Current is valid.
         } else {
           ++next_ix_;
         }
       }
     }
@@ skipping 743 matching lines @@
                                Assembler* assembler,
                                bool optimized = false);
   static RawCode* FinalizeCode(const char* name,
                                Assembler* assembler,
                                bool optimized = false);
   static RawCode* LookupCode(uword pc);
   static RawCode* LookupCodeInVmIsolate(uword pc);
   static RawCode* FindCode(uword pc, int64_t timestamp);
 
   int32_t GetPointerOffsetAt(int index) const {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     return *PointerOffsetAddrAt(index);
   }
   intptr_t GetTokenIndexOfPC(uword pc) const;
 
   enum {
     kInvalidPc = -1
   };
 
   // Returns 0 if code is not patchable
   uword GetEntryPatchPc() const;
@@ skipping 90 matching lines @@
     ASSERT(Utils::IsUint(30, value));
     set_state_bits(PtrOffBits::update(value, raw_ptr()->state_bits_));
   }
   int32_t* PointerOffsetAddrAt(int index) const {
     ASSERT(index >= 0);
     ASSERT(index < pointer_offsets_length());
     // TODO(iposva): Unit test is missing for this functionality.
     return &UnsafeMutableNonPointer(raw_ptr()->data())[index];
   }
   void SetPointerOffsetAt(int index, int32_t offset_in_instructions) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     *PointerOffsetAddrAt(index) = offset_in_instructions;
   }
 
   // Currently slow, as it searches linearly through inlined_intervals().
   intptr_t GetCallerId(intptr_t inlined_id) const;
 
   intptr_t BinarySearchInSCallTable(uword pc) const;
   static RawCode* LookupCodeInIsolate(Isolate* isolate, uword pc);
 
   // New is a private method as RawInstruction and RawCode objects should
@@ skipping 1800 matching lines @@
 
 class OneByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsOneByteString());
     return raw_ptr(str)->data()[index];
   }
 
   static void SetCharAt(const String& str, intptr_t index, uint8_t code_unit) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     *CharAddr(str, index) = code_unit;
   }
   static RawOneByteString* EscapeSpecialCharacters(const String& str);
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t data_offset() {
     return OFFSET_OF_RETURNED_VALUE(RawOneByteString, data);
   }
@@ skipping 110 matching lines @@
 
 class TwoByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsTwoByteString());
     return raw_ptr(str)->data()[index];
   }
 
   static void SetCharAt(const String& str, intptr_t index, uint16_t ch) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     *CharAddr(str, index) = ch;
   }
 
   static RawTwoByteString* EscapeSpecialCharacters(const String& str);
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 2;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t data_offset() {
@@ skipping 85 matching lines @@
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalOneByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
     return raw_ptr(str)->external_data_->peer();
   }
 
   static intptr_t external_data_offset() {
     return OFFSET_OF(RawExternalOneByteString, external_data_);
   }
@@ skipping 59 matching lines @@
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalTwoByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
     return raw_ptr(str)->external_data_->peer();
   }
 
   static intptr_t external_data_offset() {
     return OFFSET_OF(RawExternalTwoByteString, external_data_);
   }
@@ skipping 107 matching lines @@
     return OFFSET_OF_RETURNED_VALUE(RawArray, data);
   }
   static intptr_t element_offset(intptr_t index) {
     return OFFSET_OF_RETURNED_VALUE(RawArray, data) + kWordSize * index;
   }
 
   RawObject* At(intptr_t index) const {
     return *ObjectAddr(index);
   }
   void SetAt(intptr_t index, const Object& value) const {
-    // TODO(iposva): Add storing NoGCScope.
+    // TODO(iposva): Add storing NoSafepointScope.
     StorePointer(ObjectAddr(index), value.raw());
   }
 
   bool IsImmutable() const {
     return raw()->GetClassId() == kImmutableArrayCid;
   }
 
   virtual RawTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
   }
@@ skipping 111 matching lines @@
     return reinterpret_cast<RawImmutableArray*>(array.raw());
   }
 
   friend class Class;
 };
 
 
 class GrowableObjectArray : public Instance {
  public:
   intptr_t Capacity() const {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     ASSERT(!IsNull());
     return Smi::Value(DataArray()->length_);
   }
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
   void 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));
   }
 
   RawArray* data() const { return raw_ptr()->data_; }
   void SetData(const Array& value) const {
     StorePointer(&raw_ptr()->data_, value.raw());
   }
 
   RawObject* At(intptr_t index) const {
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     ASSERT(!IsNull());
     ASSERT(index < Length());
     return *ObjectAddr(index);
   }
   void SetAt(intptr_t index, const Object& value) const {
     ASSERT(!IsNull());
     ASSERT(index < Length());
 
-    // TODO(iposva): Add storing NoGCScope.
+    // TODO(iposva): Add storing NoSafepointScope.
     DataStorePointer(ObjectAddr(index), value.raw());
   }
 
   void Add(const Object& value, Heap::Space space = Heap::kNew) const;
 
   void Grow(intptr_t new_capacity, Heap::Space space = Heap::kNew) const;
   RawObject* RemoveLast() const;
 
   virtual RawTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
@@ skipping 228 matching lines @@
     ASSERT((byte_offset == 0) ||
            ((byte_offset > 0) && (byte_offset < LengthInBytes())));
     return reinterpret_cast<void*>(
         UnsafeMutableNonPointer(raw_ptr()->data()) + byte_offset);
   }
 
   virtual bool CanonicalizeEquals(const Instance& other) const;
 
 #define TYPED_GETTER_SETTER(name, type)                                        \
   type Get##name(intptr_t byte_offset) const {                                 \
-    NoGCScope no_gc;                                                           \
+    NoSafepointScope no_safepoint;                                             \
     return *reinterpret_cast<type*>(DataAddr(byte_offset));                    \
   }                                                                            \
   void Set##name(intptr_t byte_offset, type value) const {                     \
-    NoGCScope no_gc;                                                           \
+    NoSafepointScope no_safepoint;                                             \
     *reinterpret_cast<type*>(DataAddr(byte_offset)) = value;                   \
   }
   TYPED_GETTER_SETTER(Int8, int8_t)
   TYPED_GETTER_SETTER(Uint8, uint8_t)
   TYPED_GETTER_SETTER(Int16, int16_t)
   TYPED_GETTER_SETTER(Uint16, uint16_t)
   TYPED_GETTER_SETTER(Int32, int32_t)
   TYPED_GETTER_SETTER(Uint32, uint32_t)
   TYPED_GETTER_SETTER(Int64, int64_t)
   TYPED_GETTER_SETTER(Uint64, uint64_t)
@@ skipping 48 matching lines @@
   static void Copy(const DstType& dst, intptr_t dst_offset_in_bytes,
                    const SrcType& src, intptr_t src_offset_in_bytes,
                    intptr_t length_in_bytes) {
     ASSERT(Utils::RangeCheck(src_offset_in_bytes,
                              length_in_bytes,
                              src.LengthInBytes()));
     ASSERT(Utils::RangeCheck(dst_offset_in_bytes,
                              length_in_bytes,
                              dst.LengthInBytes()));
     {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       if (length_in_bytes > 0) {
         memmove(dst.DataAddr(dst_offset_in_bytes),
                 src.DataAddr(src_offset_in_bytes),
                 length_in_bytes);
       }
     }
   }
 
 
   template <typename DstType, typename SrcType>
   static void ClampedCopy(const DstType& dst, intptr_t dst_offset_in_bytes,
                           const SrcType& src, intptr_t src_offset_in_bytes,
                           intptr_t length_in_bytes) {
     ASSERT(Utils::RangeCheck(src_offset_in_bytes,
                              length_in_bytes,
                              src.LengthInBytes()));
     ASSERT(Utils::RangeCheck(dst_offset_in_bytes,
                              length_in_bytes,
                              dst.LengthInBytes()));
     {
-      NoGCScope no_gc;
+      NoSafepointScope no_safepoint;
       if (length_in_bytes > 0) {
         uint8_t* dst_data =
             reinterpret_cast<uint8_t*>(dst.DataAddr(dst_offset_in_bytes));
         int8_t* src_data =
             reinterpret_cast<int8_t*>(src.DataAddr(src_offset_in_bytes));
         for (intptr_t ix = 0; ix < length_in_bytes; ix++) {
           int8_t v = *src_data;
           if (v < 0) v = 0;
           *dst_data = v;
           src_data++;
@@ skipping 709 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Object& value) const {
   StorePointer(ObjectAddr(index), value.raw());
 }
 
 
 intptr_t Instance::GetNativeField(int index) const {
   ASSERT(IsValidNativeIndex(index));
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   RawTypedData* native_fields =
       reinterpret_cast<RawTypedData*>(*NativeFieldsAddr());
   if (native_fields == TypedData::null()) {
     return 0;
   }
   return reinterpret_cast<intptr_t*>(native_fields->ptr()->data())[index];
 }
 
 
 void Instance::GetNativeFields(uint16_t num_fields,
                                intptr_t* field_values) const {
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   ASSERT(num_fields == NumNativeFields());
   ASSERT(field_values != NULL);
   RawTypedData* native_fields =
       reinterpret_cast<RawTypedData*>(*NativeFieldsAddr());
   if (native_fields == TypedData::null()) {
     for (intptr_t i = 0; i < num_fields; i++) {
       field_values[i] = 0;
     }
   }
   intptr_t* fields = reinterpret_cast<intptr_t*>(native_fields->ptr()->data());
@@ skipping 55 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_