Revert "Remember inside an ICData if it is for a static call or an instance call"

runtime/vm/isolate_reload.cc

 // Copyright (c) 2016, 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/isolate_reload.h"
 
 #include "vm/become.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 863 matching lines @@
         reinterpret_cast<RawObject**>(&saved_class_table_[0]), saved_num_cids_);
   }
 }
 
 
 ObjectStore* IsolateReloadContext::object_store() {
   return isolate_->object_store();
 }
 
 
+static void ResetICs(const Function& function, const Code& code) {
+  // TODO(johnmccutchan): Relying on the function's ICData Map can miss ICDatas.
+  // Use the code's object pool instead.
+  if (function.ic_data_array() == Array::null()) {
+    // TODO(johnmccutchan): Even in this case, we need to scan the code's object
+    // pool instead.
+    return;  // Already reset in an earlier round.
+  }
+
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+
+  ZoneGrowableArray<const ICData*>* ic_data_array =
+      new(zone) ZoneGrowableArray<const ICData*>();
+  function.RestoreICDataMap(ic_data_array, false /* clone ic-data */);
+  const intptr_t ic_data_array_length = ic_data_array->length();
+  if (ic_data_array_length == 0) {
+    return;
+  }
+  const PcDescriptors& descriptors =
+      PcDescriptors::Handle(code.pc_descriptors());
+  PcDescriptors::Iterator iter(descriptors, RawPcDescriptors::kIcCall |
+                                            RawPcDescriptors::kUnoptStaticCall);
+  while (iter.MoveNext()) {
+    const intptr_t index = iter.DeoptId();
+    if (index >= ic_data_array_length) {
+      // TODO(johnmccutchan): Investigate how this can happen.
+      continue;
+    }
+    const ICData* ic_data = (*ic_data_array)[index];
+    if (ic_data == NULL) {
+      // TODO(johnmccutchan): Investigate how this can happen.
+      continue;
+    }
+    bool is_static_call = iter.Kind() == RawPcDescriptors::kUnoptStaticCall;
+    ic_data->Reset(is_static_call);
+  }
+}
+
+
 void IsolateReloadContext::ResetUnoptimizedICsOnStack() {
   Code& code = Code::Handle();
   Function& function = Function::Handle();
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
   while (frame != NULL) {
     code = frame->LookupDartCode();
     if (code.is_optimized()) {
       // If this code is optimized, we need to reset the ICs in the
       // corresponding unoptimized code, which will be executed when the stack
       // unwinds to the the optimized code.
       function = code.function();
       code = function.unoptimized_code();
       ASSERT(!code.IsNull());
-      code.ResetICDatas(function);
+      ResetICs(function, code);
     } else {
       function = code.function();
-      code.ResetICDatas(function);
+      ResetICs(function, code);
     }
     frame = iterator.NextFrame();
   }
 }
 
 
 void IsolateReloadContext::ResetMegamorphicCaches() {
   object_store()->set_megamorphic_cache_table(GrowableObjectArray::Handle());
   // Since any current optimized code will not make any more calls, it may be
   // better to clear the table instead of clearing each of the caches, allow
@@ skipping 56 matching lines @@
     // Null out the ICData array and code.
     func.ClearICDataArray();
     func.ClearCode();
     func.set_was_compiled(false);
   }
 
   void PreserveUnoptimizedCode(const Function& func) {
     ASSERT(!code_.IsNull());
     // We are preserving the unoptimized code, fill all ICData arrays with
     // the sentinel values so that we have no stale type feedback.
-    code_.ResetICDatas(func);
+    func.FillICDataWithSentinels(code_);
   }
 
   bool IsFromDirtyLibrary(const Function& func) {
     owning_class_ = func.Owner();
     owning_lib_ = owning_class_.library();
     return reload_context_->IsDirty(owning_lib_);
   }
 
   Object& handle_;
   Class& owning_class_;
@@ skipping 168 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart