Reapply "Save and restore feedback from JIT."

runtime/vm/aot_optimizer.cc

 // Copyright (c) 2013, 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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 82 matching lines @@
   }
 }
 
 
 // Optimize instance calls using ICData.
 void AotOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
-void AotOptimizer::PopulateWithICData() {
-  ASSERT(current_iterator_ == NULL);
-  for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
-       !block_it.Done(); block_it.Advance()) {
-    ForwardInstructionIterator it(block_it.Current());
-    for (; !it.Done(); it.Advance()) {
-      Instruction* instr = it.Current();
-      if (instr->IsInstanceCall()) {
-        InstanceCallInstr* call = instr->AsInstanceCall();
-        if (!call->HasICData()) {
-          const Array& arguments_descriptor = Array::Handle(
-              zone(), ArgumentsDescriptor::New(call->ArgumentCount(),
-                                               call->argument_names()));
-          const ICData& ic_data = ICData::ZoneHandle(
-              zone(), ICData::New(function(), call->function_name(),
-                                  arguments_descriptor, call->deopt_id(),
-                                  call->checked_argument_count(), false));
-          call->set_ic_data(&ic_data);
-        }
-      }
-    }
-    current_iterator_ = NULL;
-  }
-}
-
-
 bool AotOptimizer::RecognizeRuntimeTypeGetter(InstanceCallInstr* call) {
   if ((precompiler_ == NULL) || !precompiler_->get_runtime_type_is_unique()) {
     return false;
   }
 
   if (call->function_name().raw() != Symbols::GetRuntimeType().raw()) {
     return false;
   }
 
   // There is only a single function Object.get:runtimeType that can be invoked
@@ skipping 1404 matching lines @@
         flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(type_cid)));
 
     StrictCompareInstr* check_cid = new (Z) StrictCompareInstr(
         call->token_pos(), negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
         new (Z) Value(left_cid), new (Z) Value(cid),
         false);  // No number check.
     ReplaceCall(call, check_cid);
     return;
   }
 
-  TypeRangeCache* cache = thread()->type_range_cache();
-  intptr_t lower_limit, upper_limit;
-  if (cache != NULL &&
-      cache->InstanceOfHasClassRange(type, &lower_limit, &upper_limit)) {
-    // left.instanceof(type) =>
-    //     _classRangeCheck(left.cid, lower_limit, upper_limit)
+  if (precompiler_ != NULL) {
+    TypeRangeCache* cache = precompiler_->type_range_cache();
+    intptr_t lower_limit, upper_limit;
+    if (cache != NULL &&
+        cache->InstanceOfHasClassRange(type, &lower_limit, &upper_limit)) {
+      // left.instanceof(type) =>
+      //     _classRangeCheck(left.cid, lower_limit, upper_limit)
 
-    LoadClassIdInstr* left_cid = new (Z) LoadClassIdInstr(new (Z) Value(left));
-    InsertBefore(call, left_cid, NULL, FlowGraph::kValue);
-    ConstantInstr* lower_cid =
-        flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(lower_limit)));
-    ConstantInstr* upper_cid =
-        flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(upper_limit)));
+      LoadClassIdInstr* left_cid =
+          new (Z) LoadClassIdInstr(new (Z) Value(left));
+      InsertBefore(call, left_cid, NULL, FlowGraph::kValue);
+      ConstantInstr* lower_cid =
+          flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(lower_limit)));
+      ConstantInstr* upper_cid =
+          flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(upper_limit)));
 
-    ZoneGrowableArray<PushArgumentInstr*>* args =
-        new (Z) ZoneGrowableArray<PushArgumentInstr*>(3);
-    PushArgumentInstr* arg = new (Z) PushArgumentInstr(new (Z) Value(left_cid));
-    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
-    args->Add(arg);
-    arg = new (Z) PushArgumentInstr(new (Z) Value(lower_cid));
-    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
-    args->Add(arg);
-    arg = new (Z) PushArgumentInstr(new (Z) Value(upper_cid));
-    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
-    args->Add(arg);
+      ZoneGrowableArray<PushArgumentInstr*>* args =
+          new (Z) ZoneGrowableArray<PushArgumentInstr*>(3);
+      PushArgumentInstr* arg =
+          new (Z) PushArgumentInstr(new (Z) Value(left_cid));
+      InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+      args->Add(arg);
+      arg = new (Z) PushArgumentInstr(new (Z) Value(lower_cid));
+      InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+      args->Add(arg);
+      arg = new (Z) PushArgumentInstr(new (Z) Value(upper_cid));
+      InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+      args->Add(arg);
 
-    const Library& dart_internal =
-        Library::Handle(Z, Library::InternalLibrary());
-    const String& target_name = negate ? Symbols::_classRangeCheckNegative()
-                                       : Symbols::_classRangeCheck();
-    const Function& target = Function::ZoneHandle(
-        Z, dart_internal.LookupFunctionAllowPrivate(target_name));
-    ASSERT(!target.IsNull());
-    ASSERT(target.IsRecognized() && target.always_inline());
+      const Library& dart_internal =
+          Library::Handle(Z, Library::InternalLibrary());
+      const String& target_name = negate ? Symbols::_classRangeCheckNegative()
+                                         : Symbols::_classRangeCheck();
+      const Function& target = Function::ZoneHandle(
+          Z, dart_internal.LookupFunctionAllowPrivate(target_name));
+      ASSERT(!target.IsNull());
+      ASSERT(target.IsRecognized() && target.always_inline());
 
-    StaticCallInstr* new_call =
-        new (Z) StaticCallInstr(call->token_pos(), target,
-                                Object::null_array(),  // argument_names
-                                args, call->deopt_id());
-    ReplaceCall(call, new_call);
-    return;
+      StaticCallInstr* new_call =
+          new (Z) StaticCallInstr(call->token_pos(), target,
+                                  Object::null_array(),  // argument_names
+                                  args, call->deopt_id());
+      ReplaceCall(call, new_call);
+      return;
+    }
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
   if ((unary_checks.NumberOfChecks() > 0) &&
       (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks)) {
     ZoneGrowableArray<intptr_t>* results =
         new (Z) ZoneGrowableArray<intptr_t>(unary_checks.NumberOfChecks() * 2);
     InstanceOfAsBool(unary_checks, type, results);
     if (results->length() == unary_checks.NumberOfChecks() * 2) {
@@ skipping 581 matching lines @@
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart