Implement new inline cache.

vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/code_generator.h"
 #include "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/debuginfo.h"
 #include "vm/growable_array.h"
 #include "vm/heap.h"
-#include "vm/ic_stubs.h"
+#include "vm/ic_data.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, expose_core_impl, false,
@@ skipping 4250 matching lines @@
   Code& result = Code::Handle();
   {
     uword size = Code::InstanceSize(pointer_offsets_length);
     RawObject* raw = Object::Allocate(cls, size, Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
   }
   result.raw_ptr()->ic_data_ = Array::Empty();
-  result.raw_ptr()->class_ic_stubs_ = Array::Empty();
   return result.raw();
 }
 
 
 RawCode* Code::FinalizeCode(const char* name, Assembler* assembler) {
   ASSERT(assembler != NULL);
 
   // Allocate the Instructions object.
   Instructions& instrs =
       Instructions::ZoneHandle(Instructions::New(assembler->CodeSize()));
@@ skipping 61 matching lines @@
 RawArray* Code::ic_data() const {
   return raw_ptr()->ic_data_;
 }
 
 
 void Code::set_ic_data(const Array& ic_data) const {
   ASSERT(!ic_data.IsNull());
   StorePointer(&raw_ptr()->ic_data_, ic_data.raw());
 }
 
-
-RawArray* Code::class_ic_stubs() const {
-  return raw_ptr()->class_ic_stubs_;
-}
-
-
-void Code::set_class_ic_stubs(const Array& class_ic_stubs) const {
-  ASSERT(!class_ic_stubs.IsNull());
-  StorePointer(&raw_ptr()->class_ic_stubs_, class_ic_stubs.raw());
-}
-
-
 intptr_t Code::GetTokenIndexOfPC(uword pc) const {
   intptr_t token_index = -1;
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (static_cast<uword>(descriptors.PC(i)) == pc) {
       token_index = descriptors.TokenIndex(i);
       break;
     }
   }
   return token_index;
 }
 
 
 uword Code::GetDeoptPcAtNodeId(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::kDeopt)) {
       return descriptors.PC(i);
     }
   }
   return 0;
 }
 
 
 const char* Code::ToCString() const {
-  const char* kFormat = "Code entry:0x%d icstubs: %d";
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat,
-      EntryPoint(),
-      (Array::Handle(class_ic_stubs()).Length() / 2)) + 1;
+  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(),
-      (Array::Handle(class_ic_stubs()).Length() / 2));
+  OS::SNPrint(chars, len, kFormat, EntryPoint());
   return chars;
 }
 
 
 uword Code::GetPatchCodePc() const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.DescriptorKind(i) == PcDescriptors::kPatchCode) {
       return descriptors.PC(i);
     }
@@ skipping 13 matching lines @@
 }
 
 
 void Code::ExtractTypesAtIcCalls(
     GrowableArray<intptr_t>* node_ids,
     GrowableArray<ZoneGrowableArray<const Class*>*>* type_arrays) const {
   ASSERT(node_ids != NULL);
   ASSERT(type_arrays != NULL);
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(this->pc_descriptors());
-  String& function_name = String::Handle();
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.DescriptorKind(i) == PcDescriptors::kIcCall) {
-      int num_arguments = -1;
-      int num_named_arguments = -1;
-      uword caller_target = 0;
-      CodePatcher::GetInstanceCallAt(descriptors.PC(i),
-                                     &function_name,
-                                     &num_arguments,
-                                     &num_named_arguments,
-                                     &caller_target);
-      GrowableArray<const Class*> classes;
-      GrowableArray<const Function*> targets;
-      bool is_ic = ICStubs::RecognizeICStub(caller_target, &classes, &targets);
-      ASSERT(is_ic);
+      ICData ic_data(Array::Handle(
+          CodePatcher::GetInstanceCallIcDataAt(descriptors.PC(i))));
+      ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
+      int len = ic_data.NumberOfChecks();
       ZoneGrowableArray<const Class*>* types =
           new ZoneGrowableArray<const Class*>();
-      for (intptr_t k = 0; k < classes.length(); k++) {
-        types->Add(classes[k]);
+      Function& target = Function::Handle();
+      for (intptr_t k = 0; k < len; k++) {
+        GrowableArray<const Class*> classes;
+        ic_data.GetCheckAt(k, &classes, &target);
+        ASSERT(classes.length() == 1);
+        types->Add(classes[0]);
       }
       node_ids->Add(descriptors.NodeId(i));
       type_arrays->Add(types);
     }
   }
 }
 
 
 RawContext* Context::New(intptr_t num_variables, Heap::Space space) {
   ASSERT(num_variables >= 0);
@@ skipping 2323 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