Remove skip_static_calls_ as it uses an obsolete way to check for uncalled static calls. Will be re…

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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 7293 matching lines @@
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_descriptors);
   }
   return result.raw();
 }
 
 
 const char* PcDescriptors::KindAsStr(intptr_t index) const {
   switch (DescriptorKind(index)) {
-    case PcDescriptors::kDeopt:         return "deopt        ";
-    case PcDescriptors::kEntryPatch:    return "entry-patch  ";
-    case PcDescriptors::kPatchCode:     return "patch        ";
-    case PcDescriptors::kLazyDeoptJump: return "lazy-deopt   ";
-    case PcDescriptors::kIcCall:        return "ic-call      ";
-    case PcDescriptors::kFuncCall:      return "fn-call      ";
-    case PcDescriptors::kClosureCall:   return "closure-call ";
-    case PcDescriptors::kReturn:        return "return       ";
-    case PcDescriptors::kRuntimeCall:   return "runtime-call ";
-    case PcDescriptors::kOsrEntry:      return "osr-entry    ";
-    case PcDescriptors::kOther:         return "other        ";
+    case PcDescriptors::kDeopt:           return "deopt        ";
+    case PcDescriptors::kEntryPatch:      return "entry-patch  ";
+    case PcDescriptors::kPatchCode:       return "patch        ";
+    case PcDescriptors::kLazyDeoptJump:   return "lazy-deopt   ";
+    case PcDescriptors::kIcCall:          return "ic-call      ";
+    case PcDescriptors::kOptStaticCall:   return "opt-call     ";
+    case PcDescriptors::kUnoptStaticCall: return "unopt-call   ";
+    case PcDescriptors::kClosureCall:     return "closure-call ";
+    case PcDescriptors::kReturn:          return "return       ";
+    case PcDescriptors::kRuntimeCall:     return "runtime-call ";
+    case PcDescriptors::kOsrEntry:        return "osr-entry    ";
+    case PcDescriptors::kOther:           return "other        ";
   }
   UNREACHABLE();
   return "";
 }
 
 
 void PcDescriptors::PrintHeaderString() {
   // 4 bits per hex digit + 2 for "0x".
   const int addr_width = (kBitsPerWord / 4) + 2;
   // "*" in a printf format specifier tells it to read the field width from
@@ skipping 900 matching lines @@
 intptr_t Code::ExtractIcDataArraysAtCalls(
     GrowableArray<intptr_t>* node_ids,
     const GrowableObjectArray& ic_data_objs) const {
   ASSERT(node_ids != NULL);
   ASSERT(!ic_data_objs.IsNull());
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(this->pc_descriptors());
   ICData& ic_data_obj = ICData::Handle();
   intptr_t max_id = -1;
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
-    if (descriptors.DescriptorKind(i) == PcDescriptors::kIcCall) {
+    PcDescriptors::Kind kind = descriptors.DescriptorKind(i);
+    if ((kind == PcDescriptors::kIcCall) ||
+        (kind == PcDescriptors::kUnoptStaticCall)) {
       intptr_t deopt_id = descriptors.DeoptId(i);
       if (deopt_id > max_id) {
         max_id = deopt_id;
       }
       node_ids->Add(deopt_id);
-      CodePatcher::GetInstanceCallAt(descriptors.PC(i), *this, &ic_data_obj);
+      uword ret_addr = descriptors.PC(i);
+      if (kind == PcDescriptors::kIcCall) {
+        CodePatcher::GetInstanceCallAt(ret_addr, *this, &ic_data_obj);
+      } else {
+        ASSERT(kind == PcDescriptors::kUnoptStaticCall);

[siva, 2013/06/25 21:21:05]

This assert seems superfluous considering there is an
if (kind == kIcCall || kin kUnoptStatiCall) above

[srdjan, 2013/06/25 21:26:08]

Removed

+        CodePatcher::GetUnoptimizedStaticCallAt(ret_addr, *this, &ic_data_obj);
+      }
       ic_data_objs.Add(ic_data_obj);
     }
   }
   return max_id;
 }
 
 
 RawArray* Code::ExtractTypeFeedbackArray() const {
   ASSERT(!IsNull() && !is_optimized());
   GrowableArray<intptr_t> deopt_ids;
   const GrowableObjectArray& ic_data_objs =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   const intptr_t max_id =
       ExtractIcDataArraysAtCalls(&deopt_ids, ic_data_objs);
   const Array& result = Array::Handle(Array::New(max_id + 1));
   for (intptr_t i = 0; i < deopt_ids.length(); i++) {
     intptr_t result_index = deopt_ids[i];
     ASSERT(result.At(result_index) == Object::null());
     result.SetAt(result_index, Object::Handle(ic_data_objs.At(i)));
   }
   return result.raw();
 }
 
 
-void Code::ExtractUncalledStaticCallDeoptIds(
-    GrowableArray<intptr_t>* deopt_ids) const {
-  ASSERT(!IsNull() && !is_optimized());
-  ASSERT(deopt_ids != NULL);
-  deopt_ids->Clear();
-  const PcDescriptors& descriptors =
-      PcDescriptors::Handle(this->pc_descriptors());
-  for (intptr_t i = 0; i < descriptors.Length(); i++) {
-    if (descriptors.DescriptorKind(i) == PcDescriptors::kFuncCall) {
-      // Static call.
-      const uword target_addr =
-          CodePatcher::GetStaticCallTargetAt(descriptors.PC(i), *this);
-      if (target_addr == StubCode::CallStaticFunctionEntryPoint()) {
-        deopt_ids->Add(descriptors.DeoptId(i));
-      }
-    }
-  }
-}
-
-
 RawStackmap* Code::GetStackmap(uword pc, Array* maps, Stackmap* map) const {
   // This code is used during iterating frames during a GC and hence it
   // should not in turn start a GC.
   NoGCScope no_gc;
   if (stackmaps() == Array::null()) {
     // No stack maps are present in the code object which means this
     // frame relies on tagged pointers.
     return Stackmap::null();
   }
   // A stack map is present in the code object, use the stack map to visit
@@ skipping 5370 matching lines @@
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart