Using SubtypeTestCache object instead of an array, that way we do not need to patch and can communi…

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 69 matching lines @@
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::stackmap_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::var_descriptors_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::exception_handlers_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_scope_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::icdata_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::subtypetestcache_class_ =
+    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::api_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::language_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unhandled_exception_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unwind_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 #undef RAW_NULL
 
 int Object::GetSingletonClassIndex(const RawClass* raw_class) {
   ASSERT(raw_class->IsHeapObject());
   if (raw_class == class_class()) {
@@ skipping 43 matching lines @@
   } else if (raw_class == var_descriptors_class()) {
     return kLocalVarDescriptorsClass;
   } else if (raw_class == exception_handlers_class()) {
     return kExceptionHandlersClass;
   } else if (raw_class == context_class()) {
     return kContextClass;
   } else if (raw_class == context_scope_class()) {
     return kContextScopeClass;
   } else if (raw_class == icdata_class()) {
     return kICDataClass;
+  } else if (raw_class == subtypetestcache_class()) {
+    return kSubtypeTestCacheClass;
   } else if (raw_class == api_error_class()) {
     return kApiErrorClass;
   } else if (raw_class == language_error_class()) {
     return kLanguageErrorClass;
   } else if (raw_class == unhandled_exception_class()) {
     return kUnhandledExceptionClass;
   } else if (raw_class == unwind_error_class()) {
     return kUnwindErrorClass;
   }
   return kInvalidIndex;
@@ skipping 23 matching lines @@
     case kLibraryPrefixClass: return library_prefix_class();
     case kCodeClass: return code_class();
     case kInstructionsClass: return instructions_class();
     case kPcDescriptorsClass: return pc_descriptors_class();
     case kStackmapClass: return stackmap_class();
     case kLocalVarDescriptorsClass: return var_descriptors_class();
     case kExceptionHandlersClass: return exception_handlers_class();
     case kContextClass: return context_class();
     case kContextScopeClass: return context_scope_class();
     case kICDataClass: return icdata_class();
+    case kSubtypeTestCacheClass: return subtypetestcache_class();
     case kApiErrorClass: return api_error_class();
     case kLanguageErrorClass: return language_error_class();
     case kUnhandledExceptionClass: return unhandled_exception_class();
     case kUnwindErrorClass: return unwind_error_class();
     default: break;
   }
   UNREACHABLE();
   return reinterpret_cast<RawClass*>(kHeapObjectTag);  // return RAW_NULL.
 }
 
@@ skipping 20 matching lines @@
     case kLibraryPrefixClass: return "LibraryPrefix";
     case kCodeClass: return "Code";
     case kInstructionsClass: return "Instructions";
     case kPcDescriptorsClass: return "PcDescriptors";
     case kStackmapClass: return "Stackmap";
     case kLocalVarDescriptorsClass: return "LocalVarDescriptors";
     case kExceptionHandlersClass: return "ExceptionHandlers";
     case kContextClass: return "Context";
     case kContextScopeClass: return "ContextScope";
     case kICDataClass: return "ICData";
+    case kSubtypeTestCacheClass: return "SubtypeTestCache";
     case kApiErrorClass: return "ApiError";
     case kLanguageErrorClass: return "LanguageError";
     case kUnhandledExceptionClass: return "UnhandledException";
     case kUnwindErrorClass: return "UnwindError";
     default: break;
   }
   UNREACHABLE();
   return NULL;
 }
 
@@ skipping 153 matching lines @@
 
   cls = Class::New<Context>();
   context_class_ = cls.raw();
 
   cls = Class::New<ContextScope>();
   context_scope_class_ = cls.raw();
 
   cls = Class::New<ICData>();
   icdata_class_ = cls.raw();
 
+  cls = Class::New<SubtypeTestCache>();
+  subtypetestcache_class_ = cls.raw();
+
   cls = Class::New<ApiError>();
   api_error_class_ = cls.raw();
 
   cls = Class::New<LanguageError>();
   language_error_class_ = cls.raw();
 
   cls = Class::New<UnhandledException>();
   unhandled_exception_class_ = cls.raw();
 
   cls = Class::New<UnwindError>();
@@ skipping 5203 matching lines @@
 }
 
 
 const char* PcDescriptors::KindAsStr(intptr_t index) const {
   switch (DescriptorKind(index)) {
     case PcDescriptors::kDeopt: return "deopt";
     case PcDescriptors::kPatchCode: return "patch";
     case PcDescriptors::kIcCall: return "ic-call";
     case PcDescriptors::kFuncCall: return "fn-call";
     case PcDescriptors::kReturn: return "return";
-    case PcDescriptors::kTypeTest: return "ty-test";
     case PcDescriptors::kOther: return "other";
   }
   UNREACHABLE();
   return "";
 }
 
 
 const char* PcDescriptors::ToCString() const {
   if (Length() == 0) {
     return "No pc descriptors\n";
@@ skipping 407 matching lines @@
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if ((descriptors.NodeId(i) == node_id) &&
         (descriptors.DescriptorKind(i) == PcDescriptors::kDeopt)) {
       return descriptors.PC(i);
     }
   }
   return 0;
 }
 
 
-uword Code::GetTypeTestAtNodeId(intptr_t node_id) const {
-  const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
-  for (intptr_t i = 0; i < descriptors.Length(); i++) {
-    if ((descriptors.NodeId(i) == node_id) &&
-        (descriptors.DescriptorKind(i) == PcDescriptors::kTypeTest)) {
-      return descriptors.PC(i);
-    }
-  }
-  return 0;
-}
-
-
 const char* Code::ToCString() const {
   const char* kFormat = "Code entry:0x%d";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, EntryPoint());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, EntryPoint());
   return chars;
 }
 
 
@@ skipping 273 matching lines @@
 
 RawICData* ICData::New(const Function& function,
                        const String& target_name,
                        intptr_t id,
                        intptr_t num_args_tested) {
   ASSERT(num_args_tested > 0);
   const Class& cls = Class::Handle(Object::icdata_class());
   ASSERT(!cls.IsNull());
   ICData& result = ICData::Handle();
   {
-    // IC data objects ar long living objects, allocate them in old generation.
-    RawObject* raw =
-    Object::Allocate(cls, ICData::InstanceSize(), Heap::kOld);
+    // IC data objects are long living objects, allocate them in old generation.
+    RawObject* raw = Object::Allocate(cls, ICData::InstanceSize(), Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_function(function);
   result.set_target_name(target_name);
   result.set_id(id);
   result.set_num_args_tested(num_args_tested);
   // Number of array elements in one test entry (num_args_tested + 1)
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   return result.raw();
 }
 
 
+RawSubtypeTestCache* SubtypeTestCache::New() {
+  const Class& cls = Class::Handle(Object::subtypetestcache_class());
+  ASSERT(!cls.IsNull());
+  SubtypeTestCache& result = SubtypeTestCache::Handle();
+  {
+    // SubtypeTestCache objects are long living objects, allocate them in the
+    // old generation.
+    RawObject* raw =
+        Object::Allocate(cls, SubtypeTestCache::InstanceSize(), Heap::kOld);
+    NoGCScope no_gc;
+    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 {
+  // Do not count the sentinel;
+  return (Array::Handle(cache()).Length() / kTestEntryLength) - 1;
+}
+
+
+void SubtypeTestCache::AddCheck(
+    const Class& instance_class,
+    const AbstractTypeArguments& instance_type_arguments,
+    const AbstractTypeArguments& instantiator_type_arguments,
+    const Bool& test_result) const {
+  intptr_t old_num = NumberOfChecks();
+  Array& data = Array::Handle(cache());
+  intptr_t new_len = data.Length() + kTestEntryLength;
+  data = Array::Grow(data, new_len);
+  set_cache(data);
+  intptr_t data_pos = old_num * kTestEntryLength;
+  data.SetAt(data_pos + kInstanceClass, instance_class);
+  data.SetAt(data_pos + kInstanceTypeArguments, instance_type_arguments);
+  data.SetAt(data_pos + kInstantiatorTypeArguments,
+      instantiator_type_arguments);
+  data.SetAt(data_pos + kTestResult, test_result);
+}
+
+
+void SubtypeTestCache::GetCheck(
+    intptr_t ix,
+    Class* instance_class,
+    AbstractTypeArguments* instance_type_arguments,
+    AbstractTypeArguments* instantiator_type_arguments,
+    Bool* test_result) const {
+  Array& data = Array::Handle(cache());
+  intptr_t data_pos = ix * kTestEntryLength;
+  *instance_class ^= data.At(data_pos + kInstanceClass);
+  *instance_type_arguments ^= data.At(data_pos + kInstanceTypeArguments);
+  *instantiator_type_arguments ^=
+      data.At(data_pos + kInstantiatorTypeArguments);
+  *test_result ^= data.At(data_pos + kTestResult);
+}
+
+
+const char* SubtypeTestCache::ToCString() const {
+  return "SubtypeTestCache";
+}
+
+
 const char* Error::ToErrorCString() const {
   UNREACHABLE();
   return "Internal Error";
 }
 
 
 const char* Error::ToCString() const {
   // Error is an abstract class.  We should never reach here.
   UNREACHABLE();
   return "Error";
@@ skipping 2910 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart