Use off-heap data for type feedback in PolymorphicInstanceCallInstr

runtime/vm/weak_code.cc

 // Copyright (c) 2014, 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/weak_code.h"
 
 #include "platform/assert.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
 
 bool WeakCodeReferences::HasCodes() const {
   return !array_.IsNull() && (array_.Length() > 0);
 }
 
 
 void WeakCodeReferences::Register(const Code& value) {
   if (!array_.IsNull()) {
     // Try to find and reuse cleared WeakProperty to avoid allocating new one.

[Vyacheslav Egorov (Google), 2017/04/10 10:59:28]

You need to amend the comment because the code below does more than what this
comment states - because you changed how the array grows.

Additionally please reflect this change in the CL description (maybe with
rationale).

[erikcorry, 2017/04/19 15:06:41]

Moved to different CL

     WeakProperty& weak_property = WeakProperty::Handle();
-    for (intptr_t i = 0; i < array_.Length(); i++) {
+    for (intptr_t i = array_.Length() - 1; i >= 0; i--) {
       weak_property ^= array_.At(i);
+      if (weak_property.raw() == WeakProperty::null()) {
+        weak_property ^= WeakProperty::New(Heap::kOld);
+        array_.SetAt(i, weak_property);
+      }
       if (weak_property.key() == Code::null()) {
         // Empty property found. Reuse it.
         weak_property.set_key(value);
         return;
       }
     }
   }
 
   const WeakProperty& weak_property =
       WeakProperty::Handle(WeakProperty::New(Heap::kOld));
   weak_property.set_key(value);
 
   intptr_t length = array_.IsNull() ? 0 : array_.Length();
-  const Array& new_array =
-      Array::Handle(Array::Grow(array_, length + 1, Heap::kOld));
+  const Array& new_array = Array::Handle(
+      Array::Grow(array_, length + 1 + (length >> 2), Heap::kOld));
   new_array.SetAt(length, weak_property);
   UpdateArrayTo(new_array);
 }
 
 
 bool WeakCodeReferences::IsOptimizedCode(const Array& dependent_code,
                                          const Code& code) {
   if (!code.is_optimized()) {
     return false;
   }
   WeakProperty& weak_property = WeakProperty::Handle();
   for (intptr_t i = 0; i < dependent_code.Length(); i++) {
     weak_property ^= dependent_code.At(i);
-    if (code.raw() == weak_property.key()) {
+    if (weak_property.raw() != WeakProperty::null() &&
+        code.raw() == weak_property.key()) {
       return true;
     }
   }
   return false;
 }
 
 
 void WeakCodeReferences::DisableCode() {
   const Array& code_objects = Array::Handle(array_.raw());
   if (code_objects.IsNull()) {
@@ skipping 15 matching lines @@
       frame = iterator.NextFrame();
     }
   }
 
   // Switch functions that use dependent code to unoptimized code.
   WeakProperty& weak_property = WeakProperty::Handle();
   Object& owner = Object::Handle();
   Function& function = Function::Handle();
   for (intptr_t i = 0; i < code_objects.Length(); i++) {
     weak_property ^= code_objects.At(i);
+    if (weak_property.raw() == WeakProperty::null()) {
+      continue;
+    }
     code ^= weak_property.key();
     if (code.IsNull()) {
       // Code was garbage collected already.
       continue;
     }
     owner = code.owner();
     if (owner.IsFunction()) {
       function ^= owner.raw();
     } else if (owner.IsClass()) {
       Class& cls = Class::Handle();
@@ skipping 25 matching lines @@
       // Make non-OSR code non-entrant.
       if (!code.IsDisabled()) {
         ReportSwitchingCode(code);
         code.DisableDartCode();
       }
     }
   }
 }
 
 }  // namespace dart