Removes open arrays (e.g. data[0]) from raw objects.

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 1281 matching lines @@
   friend class Class;
 };
 
 
 // A TypeArguments is an array of AbstractType.
 class TypeArguments : public Object {
  public:
   intptr_t Length() const;
   RawAbstractType* TypeAt(intptr_t index) const;
   static intptr_t type_at_offset(intptr_t index) {
-    return OFFSET_OF(RawTypeArguments, types_) + index * kWordSize;
+    return OFFSET_OF_RETURNED_VALUE(
+        RawTypeArguments, types) + index * kWordSize;
   }
   void SetTypeAt(intptr_t index, const AbstractType& value) const;
 
   // The name of this type argument vector, e.g. "<T, dynamic, List<T>, Smi>".
   RawString* Name() const {
     return SubvectorName(0, Length(), kInternalName);
   }
 
   // The name of this type argument vector, e.g. "<T, dynamic, List<T>, Smi>".
   // Names of internal classes are not mapped to their public interfaces.
@@ skipping 106 matching lines @@
   }
 
   static const intptr_t kBytesPerElement = kWordSize;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t length_offset() {
     return OFFSET_OF(RawTypeArguments, length_);
   }
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawTypeArguments) == OFFSET_OF(RawTypeArguments, types_));
+    ASSERT(sizeof(RawTypeArguments) ==
+           OFFSET_OF_RETURNED_VALUE(RawTypeArguments, types));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
-    // Ensure that the types_ is not adding to the object size, which includes
+    // Ensure that the types() is not adding to the object size, which includes
     // 2 fields: instantiations_ and length_.
     ASSERT(sizeof(RawTypeArguments) == (sizeof(RawObject) + (2 * kWordSize)));
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawTypeArguments) + (len * kBytesPerElement));
   }
 
   intptr_t Hash() const;
 
   static RawTypeArguments* New(intptr_t len, Heap::Space space = Heap::kOld);
@@ skipping 1425 matching lines @@
   uword EntryPoint() const {
     return reinterpret_cast<uword>(raw_ptr()) + HeaderSize();
   }
 
   static const intptr_t kMaxElements = (kIntptrMax -
                                         (sizeof(RawInstructions) +
                                          sizeof(RawObject) +
                                          (2 * OS::kMaxPreferredCodeAlignment)));
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawInstructions) == OFFSET_OF(RawInstructions, data_));
+    ASSERT(sizeof(RawInstructions) ==
+           OFFSET_OF_RETURNED_VALUE(RawInstructions, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t size) {
     intptr_t instructions_size = Utils::RoundUp(size,
                                                 OS::PreferredCodeAlignment());
     intptr_t result = instructions_size + HeaderSize();
     ASSERT(result % OS::PreferredCodeAlignment() == 0);
     return result;
   }
@@ skipping 42 matching lines @@
               RawLocalVarDescriptors::VarInfo* info) const;
 
   void GetInfo(intptr_t var_index, RawLocalVarDescriptors::VarInfo* info) const;
 
   static const intptr_t kBytesPerElement =
       sizeof(RawLocalVarDescriptors::VarInfo);
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawLocalVarDescriptors) ==
-        OFFSET_OF(RawLocalVarDescriptors, data_));
+        OFFSET_OF_RETURNED_VALUE(RawLocalVarDescriptors, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawLocalVarDescriptors) + (len * kBytesPerElement));
   }
 
   static RawLocalVarDescriptors* New(intptr_t num_variables);
 
@@ skipping 49 matching lines @@
     SetKind(index, kind);
     SetDeoptId(index, deopt_id);
     SetTokenPos(index, token_pos);
     SetTryIndex(index, try_index);
   }
 
   static const intptr_t kBytesPerElement = (kNumberOfEntries * kWordSize);
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawPcDescriptors) == OFFSET_OF(RawPcDescriptors, data_));
+    ASSERT(sizeof(RawPcDescriptors) ==
+           OFFSET_OF_RETURNED_VALUE(RawPcDescriptors, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawPcDescriptors) + (len * kBytesPerElement));
   }
 
   static RawPcDescriptors* New(intptr_t num_descriptors);
 
@@ skipping 15 matching lines @@
   void SetKind(intptr_t index, PcDescriptors::Kind kind) const;
   void SetDeoptId(intptr_t index, intptr_t value) const;
   void SetTokenPos(intptr_t index, intptr_t value) const;
   void SetTryIndex(intptr_t index, intptr_t value) const;
 
   void SetLength(intptr_t value) const;
 
   intptr_t* EntryAddr(intptr_t index, intptr_t entry_offset) const {
     ASSERT((index >=0) && (index < Length()));
     intptr_t data_index = (index * kNumberOfEntries) + entry_offset;
-    return &raw_ptr()->data_[data_index];
+    return &raw_ptr()->data()[data_index];
   }
   RawSmi** SmiAddr(intptr_t index, intptr_t entry_offset) const {
     return reinterpret_cast<RawSmi**>(EntryAddr(index, entry_offset));
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(PcDescriptors, Object);
   friend class Class;
   friend class Object;
 };
 
@@ skipping 14 matching lines @@
   void SetPC(uword value) const { raw_ptr()->pc_ = value; }
 
   intptr_t RegisterBitCount() const { return raw_ptr()->register_bit_count_; }
   void SetRegisterBitCount(intptr_t register_bit_count) const {
     raw_ptr()->register_bit_count_ = register_bit_count;
   }
 
   static const intptr_t kMaxLengthInBytes = kSmiMax;
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawStackmap) == OFFSET_OF(RawStackmap, data_));
+    ASSERT(sizeof(RawStackmap) == OFFSET_OF_RETURNED_VALUE(RawStackmap, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t length) {
     ASSERT(length >= 0);
     // The stackmap payload is in an array of bytes.
     intptr_t payload_size =
         Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
     return RoundedAllocationSize(sizeof(RawStackmap) + payload_size);
   }
   static RawStackmap* New(intptr_t pc_offset,
@@ skipping 29 matching lines @@
                       intptr_t outer_try_index,
                       intptr_t handler_pc,
                       bool needs_stacktrace,
                       bool has_catch_all) const;
 
   RawArray* GetHandledTypes(intptr_t try_index) const;
   void SetHandledTypes(intptr_t try_index, const Array& handled_types) const;
   bool HasCatchAll(intptr_t try_index) const;
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawExceptionHandlers) == OFFSET_OF(RawExceptionHandlers,
-                                                     data_));
+    ASSERT(sizeof(RawExceptionHandlers) ==
+           OFFSET_OF_RETURNED_VALUE(RawExceptionHandlers, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(
         sizeof(RawExceptionHandlers) +
             (len * sizeof(RawExceptionHandlers::HandlerInfo)));
   }
 
   static RawExceptionHandlers* New(intptr_t num_handlers);
 
@@ skipping 48 matching lines @@
 
   // Returns the number of kMaterializeObject instructions in the prefix.
   intptr_t NumMaterializations() const;
 
   static RawDeoptInfo* New(intptr_t num_commands);
 
   static const intptr_t kBytesPerElement = (kNumberOfEntries * kWordSize);
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawDeoptInfo) == OFFSET_OF(RawDeoptInfo, data_));
+    ASSERT(sizeof(RawDeoptInfo) ==
+           OFFSET_OF_RETURNED_VALUE(RawDeoptInfo, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(sizeof(RawDeoptInfo) +
                                  (len * kBytesPerElement));
   }
 
   // 'index' corresponds to target, to-index.
@@ skipping 15 matching lines @@
 
   // Returns true iff decompression yields the same instructions as the
   // original.
   bool VerifyDecompression(const GrowableArray<DeoptInstr*>& original,
                            const Array& deopt_table) const;
 
  private:
   intptr_t* EntryAddr(intptr_t index, intptr_t entry_offset) const {
     ASSERT((index >=0) && (index < Length()));
     intptr_t data_index = (index * kNumberOfEntries) + entry_offset;
-    return &raw_ptr()->data_[data_index];
+    return &raw_ptr()->data()[data_index];
   }
 
   void SetLength(intptr_t value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(DeoptInfo, Object);
   friend class Class;
 };
 
 
 // Object holding information about an IC: test classes and their
@@ skipping 370 matching lines @@
 
   void set_owner(const Class& cls) {
     ASSERT(cls.IsOld());
     StorePointer(&raw_ptr()->owner_, reinterpret_cast<RawObject*>(cls.raw()));
   }
 
   // We would have a VisitPointers function here to traverse all the
   // embedded objects in the instructions using pointer_offsets.
 
   static const intptr_t kBytesPerElement =
-      sizeof(reinterpret_cast<RawCode*>(0)->data_[0]);
+      sizeof(reinterpret_cast<RawCode*>(0)->data()[0]);
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawCode) == OFFSET_OF(RawCode, data_));
+    ASSERT(sizeof(RawCode) == OFFSET_OF_RETURNED_VALUE(RawCode, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(sizeof(RawCode) + (len * kBytesPerElement));
   }
   static RawCode* FinalizeCode(const Function& function,
                                Assembler* assembler,
                                bool optimized = false);
   static RawCode* FinalizeCode(const char* name,
@@ skipping 107 matching lines @@
     raw_ptr()->instructions_ = instructions;
   }
   void set_pointer_offsets_length(intptr_t value) {
     ASSERT(value >= 0);
     raw_ptr()->pointer_offsets_length_ = value;
   }
   int32_t* PointerOffsetAddrAt(int index) const {
     ASSERT(index >= 0);
     ASSERT(index < pointer_offsets_length());
     // TODO(iposva): Unit test is missing for this functionality.
-    return &raw_ptr()->data_[index];
+    return &raw_ptr()->data()[index];
   }
   void SetPointerOffsetAt(int index, int32_t offset_in_instructions) {
     *PointerOffsetAddrAt(index) = offset_in_instructions;
   }
 
   intptr_t BinarySearchInSCallTable(uword pc) const;
   static RawCode* LookupCodeInIsolate(Isolate* isolate, uword pc);
 
   // New is a private method as RawInstruction and RawCode objects should
   // only be created using the Code::FinalizeCode method. This method creates
@@ skipping 11 matching lines @@
 
 
 class Context : public Object {
  public:
   RawContext* parent() const { return raw_ptr()->parent_; }
   void set_parent(const Context& parent) const {
     ASSERT(parent.IsNull() || parent.isolate() == Isolate::Current());
     StorePointer(&raw_ptr()->parent_, parent.raw());
   }
   static intptr_t parent_offset() { return OFFSET_OF(RawContext, parent_); }
+  static intptr_t data_offset() { return parent_offset() + kWordSize; }
 
   Isolate* isolate() const { return raw_ptr()->isolate_; }
   static intptr_t isolate_offset() { return OFFSET_OF(RawContext, isolate_); }
 
   intptr_t num_variables() const { return raw_ptr()->num_variables_; }
   static intptr_t num_variables_offset() {
     return OFFSET_OF(RawContext, num_variables_);
   }
 
   RawInstance* At(intptr_t context_index) const {
     return *InstanceAddr(context_index);
   }
   inline void SetAt(intptr_t context_index, const Instance& value) const;
 
   void Dump(int indent = 0) const;
 
   static const intptr_t kBytesPerElement = kWordSize;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t variable_offset(intptr_t context_index) {
-    return OFFSET_OF(RawContext, data_[context_index]);
+    return data_offset() + kWordSize * context_index;
   }
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawContext) == OFFSET_OF(RawContext, data_));
+    ASSERT(sizeof(RawContext) == OFFSET_OF_RETURNED_VALUE(RawContext, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(sizeof(RawContext) + (len * kBytesPerElement));
   }
 
   static RawContext* New(intptr_t num_variables,
                          Heap::Space space = Heap::kNew);
 
  private:
   RawInstance** InstanceAddr(intptr_t context_index) const {
     ASSERT((context_index >= 0) && (context_index < num_variables()));
-    return &raw_ptr()->data_[context_index];
+    return &raw_ptr()->data()[context_index];
   }
 
   void set_isolate(Isolate* isolate) const {
     raw_ptr()->isolate_ = isolate;
   }
 
   void set_num_variables(intptr_t num_variables) const {
     raw_ptr()->num_variables_ = num_variables;
   }
 
@@ skipping 37 matching lines @@
   void SetContextIndexAt(intptr_t scope_index, intptr_t context_index) const;
 
   intptr_t ContextLevelAt(intptr_t scope_index) const;
   void SetContextLevelAt(intptr_t scope_index, intptr_t context_level) const;
 
   static const intptr_t kBytesPerElement =
       sizeof(RawContextScope::VariableDesc);
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawContextScope) == OFFSET_OF(RawContextScope, data_));
+    ASSERT(sizeof(RawContextScope) ==
+           OFFSET_OF_RETURNED_VALUE(RawContextScope, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawContextScope) + (len * kBytesPerElement));
   }
 
   static RawContextScope* New(intptr_t num_variables);
@@ skipping 1630 matching lines @@
   }
 
   static void SetCharAt(const String& str, intptr_t index, uint8_t code_point) {
     *CharAddr(str, index) = code_point;
   }
   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(RawOneByteString, data_); }
+  static intptr_t data_offset() {
+    return OFFSET_OF_RETURNED_VALUE(RawOneByteString, data);
+  }
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawOneByteString) == OFFSET_OF(RawOneByteString, data_));
+    ASSERT(sizeof(RawOneByteString) ==
+           OFFSET_OF_RETURNED_VALUE(RawOneByteString, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(sizeof(RawOneByteString) == String::kSizeofRawString);
     ASSERT(0 <= len && len <= kMaxElements);
     return String::RoundedAllocationSize(
         sizeof(RawOneByteString) + (len * kBytesPerElement));
   }
 
@@ skipping 72 matching lines @@
   }
 
   static RawOneByteString* raw_ptr(const String& str) {
     return reinterpret_cast<RawOneByteString*>(str.raw_ptr());
   }
 
   static uint8_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsOneByteString());
     NoGCScope no_gc;
-    return &raw_ptr(str)->data_[index];
+    return &raw_ptr(str)->data()[index];
   }
 
   static RawOneByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind);
 
   friend class Class;
   friend class String;
   friend class ExternalOneByteString;
@@ skipping 10 matching lines @@
   static void SetCharAt(const String& str, intptr_t index, uint16_t ch) {
     *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() { return OFFSET_OF(RawTwoByteString, data_); }
+  static intptr_t data_offset() {
+    return OFFSET_OF_RETURNED_VALUE(RawTwoByteString, data);
+  }
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawTwoByteString) == OFFSET_OF(RawTwoByteString, data_));
+    ASSERT(sizeof(RawTwoByteString) ==
+           OFFSET_OF_RETURNED_VALUE(RawTwoByteString, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(sizeof(RawTwoByteString) == String::kSizeofRawString);
     ASSERT(0 <= len && len <= kMaxElements);
     return String::RoundedAllocationSize(
         sizeof(RawTwoByteString) + (len * kBytesPerElement));
   }
 
@@ skipping 43 matching lines @@
   }
 
   static RawTwoByteString* raw_ptr(const String& str) {
     return reinterpret_cast<RawTwoByteString*>(str.raw_ptr());
   }
 
   static uint16_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsTwoByteString());
     NoGCScope no_gc;
-    return &raw_ptr(str)->data_[index];
+    return &raw_ptr(str)->data()[index];
   }
 
   static RawTwoByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind);
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
@@ skipping 559 matching lines @@
   }
 
   intptr_t LengthInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return (ElementSizeInBytes(cid) * Length());
   }
 
   void* DataAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset == 0) ||
            ((byte_offset > 0) && (byte_offset < LengthInBytes())));
-    return reinterpret_cast<void*>(raw_ptr()->data_ + byte_offset);
+    return reinterpret_cast<void*>(raw_ptr()->data() + byte_offset);
   }
 
 #define TYPED_GETTER_SETTER(name, type)                                        \
   type Get##name(intptr_t byte_offset) const {                                 \
     return *reinterpret_cast<type*>(DataAddr(byte_offset));                    \
   }                                                                            \
   void Set##name(intptr_t byte_offset, type value) const {                     \
     *reinterpret_cast<type*>(DataAddr(byte_offset)) = value;                   \
   }
   TYPED_GETTER_SETTER(Int8, int8_t)
@@ skipping 10 matching lines @@
   TYPED_GETTER_SETTER(Int32x4, simd128_value_t)
   TYPED_GETTER_SETTER(Float64x2, simd128_value_t)
 
 #undef TYPED_GETTER_SETTER
 
   static intptr_t length_offset() {
     return OFFSET_OF(RawTypedData, length_);
   }
 
   static intptr_t data_offset() {
-    return OFFSET_OF(RawTypedData, data_);
+    return OFFSET_OF_RETURNED_VALUE(RawTypedData, data);
   }
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawTypedData) == OFFSET_OF(RawTypedData, data_));
+    ASSERT(sizeof(RawTypedData) ==
+           OFFSET_OF_RETURNED_VALUE(RawTypedData, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t lengthInBytes) {
     ASSERT(0 <= lengthInBytes && lengthInBytes <= kSmiMax);
     return RoundedAllocationSize(sizeof(RawTypedData) + lengthInBytes);
   }
 
   static intptr_t ElementSizeInBytes(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataClassId(class_id));
@@ skipping 475 matching lines @@
   void* GetDataStartAddress() const;
   static RawJSRegExp* FromDataStartAddress(void* data);
   const char* Flags() const;
 
   virtual bool CanonicalizeEquals(const Instance& other) const;
 
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawJSRegExp) == OFFSET_OF(RawJSRegExp, data_));
+    ASSERT(sizeof(RawJSRegExp) == OFFSET_OF_RETURNED_VALUE(RawJSRegExp, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawJSRegExp) + (len * kBytesPerElement));
   }
 
   static RawJSRegExp* New(intptr_t length, Heap::Space space = Heap::kNew);
@@ skipping 181 matching lines @@
 
 
 intptr_t Instance::GetNativeField(int index) const {
   ASSERT(IsValidNativeIndex(index));
   NoGCScope no_gc;
   RawTypedData* native_fields =
       reinterpret_cast<RawTypedData*>(*NativeFieldsAddr());
   if (native_fields == TypedData::null()) {
     return 0;
   }
-  return reinterpret_cast<intptr_t*>(native_fields->ptr()->data_)[index];
+  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;
   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_);
+  intptr_t* fields = reinterpret_cast<intptr_t*>(native_fields->ptr()->data());
   for (intptr_t i = 0; i < num_fields; i++) {
     field_values[i] = fields[i];
   }
 }
 
 
 bool String::Equals(const String& str) const {
   if (raw() == str.raw()) {
     return true;  // Both handles point to the same raw instance.
   }
@@ skipping 38 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_