- Make RawICData a subclass of RawObject and not RawInstance.

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 67 matching lines @@
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_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::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);
-RawClass* Object::icdata_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()) {
     return kClassClass;
   } else if (raw_class == null_class()) {
     return kNullClass;
   } else if (raw_class == dynamic_class()) {
     return kDynamicClass;
@@ skipping 34 matching lines @@
   } else if (raw_class == pc_descriptors_class()) {
     return kPcDescriptorsClass;
   } 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 == 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;
-  } else if (raw_class == icdata_class()) {
-    return kICDataClass;
   }
   return kInvalidIndex;
 }
 
 
 RawClass* Object::GetSingletonClass(int index) {
   switch (index) {
     case kClassClass: return class_class();
     case kNullClass: return null_class();
     case kDynamicClass: return dynamic_class();
@@ skipping 13 matching lines @@
     case kScriptClass: return script_class();
     case kLibraryClass: return library_class();
     case kLibraryPrefixClass: return library_prefix_class();
     case kCodeClass: return code_class();
     case kInstructionsClass: return instructions_class();
     case kPcDescriptorsClass: return pc_descriptors_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 kApiErrorClass: return api_error_class();
     case kLanguageErrorClass: return language_error_class();
     case kUnhandledExceptionClass: return unhandled_exception_class();
     case kUnwindErrorClass: return unwind_error_class();
-    case kICDataClass: return icdata_class();
     default: break;
   }
   UNREACHABLE();
   return reinterpret_cast<RawClass*>(kHeapObjectTag);  // return RAW_NULL.
 }
 
 
 const char* Object::GetSingletonClassName(int index) {
   switch (index) {
     case kClassClass: return "Class";
@@ skipping 13 matching lines @@
     case kScriptClass: return "Script";
     case kLibraryClass: return "Library";
     case kLibraryPrefixClass: return "LibraryPrefix";
     case kCodeClass: return "Code";
     case kInstructionsClass: return "Instructions";
     case kPcDescriptorsClass: return "PcDescriptors";
     case kLocalVarDescriptorsClass: return "LocalVarDescriptors";
     case kExceptionHandlersClass: return "ExceptionHandlers";
     case kContextClass: return "Context";
     case kContextScopeClass: return "ContextScope";
+    case kICDataClass: return "ICData";
     case kApiErrorClass: return "ApiError";
     case kLanguageErrorClass: return "LanguageError";
     case kUnhandledExceptionClass: return "UnhandledException";
     case kUnwindErrorClass: return "UnwindError";
     default: break;
   }
   UNREACHABLE();
   return NULL;
 }
 
@@ skipping 130 matching lines @@
 
   cls = Class::New<ExceptionHandlers>();
   exception_handlers_class_ = cls.raw();
 
   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<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>();
   unwind_error_class_ = cls.raw();
 
-  cls = Class::New<ICData>();
-  icdata_class_ = cls.raw();
-
   ASSERT(class_class() != null_);
 }
 
 
 RawClass* Object::CreateAndRegisterInterface(const char* cname,
                                              const Script& script,
                                              const Library& lib) {
   const String& name = String::Handle(String::NewSymbol(cname));
   const Class& cls = Class::Handle(
       Class::NewInterface(name, script, Scanner::kDummyTokenIndex));
@@ skipping 5462 matching lines @@
                                      intptr_t context_level) const {
   VariableDescAddr(scope_index)->context_level = Smi::New(context_level);
 }
 
 
 const char* ContextScope::ToCString() const {
   return "ContextScope";
 }
 
 
+const char* ICData::ToCString() const {
+  return "ICData";
+}
+
+
+void ICData::set_function(const Function& value) const {
+  raw_ptr()->function_ = value.raw();
+}
+
+
+void ICData::set_target_name(const String& value) const {
+  raw_ptr()->target_name_ = value.raw();
+}
+
+
+void ICData::set_id(intptr_t value) const {
+  raw_ptr()->id_ = value;
+}
+
+
+void ICData::set_num_args_tested(intptr_t value) const {
+  raw_ptr()->num_args_tested_ = value;
+}
+
+
+void ICData::set_ic_data(const Array& value) const {
+  raw_ptr()->ic_data_ = value.raw();
+}
+
+
+intptr_t ICData::TestEntryLength() const {
+  return num_args_tested() + 1 /* target function*/;
+}
+
+
+intptr_t ICData::NumberOfChecks() const {
+  // Do not count the sentinel;
+  return (Array::Handle(ic_data()).Length() / TestEntryLength()) - 1;
+}
+
+
+void ICData::AddCheck(const GrowableArray<const Class*>& classes,
+                      const Function& target) const {
+  ASSERT(classes.length() == num_args_tested());
+  intptr_t old_num = NumberOfChecks();
+  Array& data = Array::Handle(ic_data());
+  intptr_t new_len = data.Length() + TestEntryLength();
+  data = Array::Grow(data, new_len, Heap::kOld);
+  set_ic_data(data);
+  intptr_t data_pos = old_num * TestEntryLength();
+  for (intptr_t i = 0; i < classes.length(); i++) {
+    // Null is used as terminating value, do not add it.
+    ASSERT(!classes[i]->IsNull());
+    data.SetAt(data_pos++, *(classes[i]));
+  }
+  ASSERT(!target.IsNull());
+  data.SetAt(data_pos, target);
+}
+
+
+void ICData::GetCheckAt(intptr_t index,
+                        GrowableArray<const Class*>* classes,
+                        Function* target) const {
+  ASSERT(classes != NULL);
+  ASSERT(target != NULL);
+  classes->Clear();
+  const Array& data = Array::Handle(ic_data());
+  intptr_t data_pos = index * TestEntryLength();
+  for (intptr_t i = 0; i < num_args_tested(); i++) {
+    Class& cls = Class::ZoneHandle();
+    cls ^= data.At(data_pos++);
+    classes->Add(&cls);
+  }
+  (*target) ^= data.At(data_pos);
+}
+
+
+void ICData::GetOneClassCheckAt(
+    int index, Class* cls, Function* target) const {
+  ASSERT(cls != NULL);
+  ASSERT(target != NULL);
+  ASSERT(num_args_tested() == 1);
+  const Array& data = Array::Handle(ic_data());
+  intptr_t data_pos = index * TestEntryLength();
+  *cls ^= data.At(data_pos);
+  *target ^= data.At(data_pos + 1);
+}
+
+
+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);
+    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();
+}
+
+
 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 2853 matching lines @@
 const char* JSRegExp::ToCString() const {
   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;
 }
 
-
-const char* ICData::ToCString() const {
-  return "ICData";
-}
-
-
-void ICData::set_function(const Function& value) const {
-  raw_ptr()->function_ = value.raw();
-}
-
-
-void ICData::set_target_name(const String& value) const {
-  raw_ptr()->target_name_ = value.raw();
-}
-
-
-void ICData::set_id(intptr_t value) const {
-  raw_ptr()->id_ = value;
-}
-
-
-void ICData::set_num_args_tested(intptr_t value) const {
-  raw_ptr()->num_args_tested_ = value;
-}
-
-
-void ICData::set_ic_data(const Array& value) const {
-  raw_ptr()->ic_data_ = value.raw();
-}
-
-
-intptr_t ICData::TestEntryLength() const {
-  return num_args_tested() + 1 /* target function*/;
-}
-
-
-intptr_t ICData::NumberOfChecks() const {
-  // Do not count the sentinel;
-  return (Array::Handle(ic_data()).Length() / TestEntryLength()) - 1;
-}
-
-
-void ICData::AddCheck(const GrowableArray<const Class*>& classes,
-                      const Function& target) const {
-  ASSERT(classes.length() == num_args_tested());
-  intptr_t old_num = NumberOfChecks();
-  Array& data = Array::Handle(ic_data());
-  intptr_t new_len = data.Length() + TestEntryLength();
-  data = Array::Grow(data, new_len, Heap::kOld);
-  set_ic_data(data);
-  intptr_t data_pos = old_num * TestEntryLength();
-  for (intptr_t i = 0; i < classes.length(); i++) {
-    // Null is used as terminating value, do not add it.
-    ASSERT(!classes[i]->IsNull());
-    data.SetAt(data_pos++, *(classes[i]));
-  }
-  ASSERT(!target.IsNull());
-  data.SetAt(data_pos, target);
-}
-
-
-void ICData::GetCheckAt(intptr_t index,
-                        GrowableArray<const Class*>* classes,
-                        Function* target) const {
-  ASSERT(classes != NULL);
-  ASSERT(target != NULL);
-  classes->Clear();
-  const Array& data = Array::Handle(ic_data());
-  intptr_t data_pos = index * TestEntryLength();
-  for (intptr_t i = 0; i < num_args_tested(); i++) {
-    Class& cls = Class::ZoneHandle();
-    cls ^= data.At(data_pos++);
-    classes->Add(&cls);
-  }
-  (*target) ^= data.At(data_pos);
-}
-
-
-void ICData::GetOneClassCheckAt(
-    int index, Class* cls, Function* target) const {
-  ASSERT(cls != NULL);
-  ASSERT(target != NULL);
-  ASSERT(num_args_tested() == 1);
-  const Array& data = Array::Handle(ic_data());
-  intptr_t data_pos = index * TestEntryLength();
-  *cls ^= data.At(data_pos);
-  *target ^= data.At(data_pos + 1);
-}
-
-
-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);
-    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();
-}
-
 }  // namespace dart