Reapply "Save and restore feedback from JIT."

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 15 matching lines @@
 #include "vm/flow_graph_type_propagator.h"
 #include "vm/hash_table.h"
 #include "vm/il_printer.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/parser.h"
+#include "vm/program_visitor.h"
 #include "vm/redundancy_elimination.h"
 #include "vm/regexp_assembler.h"
 #include "vm/regexp_parser.h"
 #include "vm/resolver.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/timeline.h"
 #include "vm/timer.h"
 #include "vm/type_table.h"
+#include "vm/version.h"
+#include "vm/json_parser.h"
 
 namespace dart {
 
-
 #define T (thread())
 #define I (isolate())
 #define Z (zone())
 
 
 DEFINE_FLAG(bool, print_unique_targets, false, "Print unique dynaic targets");
 DEFINE_FLAG(bool, trace_precompiler, false, "Trace precompiler.");
 DEFINE_FLAG(
     int,
     max_speculative_inlining_attempts,
@@ skipping 10 matching lines @@
 DECLARE_FLAG(bool, range_analysis);
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, trace_optimizing_compiler);
 DECLARE_FLAG(bool, trace_bailout);
 DECLARE_FLAG(bool, use_inlining);
 DECLARE_FLAG(bool, verify_compiler);
 DECLARE_FLAG(bool, huge_method_cutoff_in_code_size);
 DECLARE_FLAG(bool, trace_failed_optimization_attempts);
 DECLARE_FLAG(bool, trace_inlining_intervals);
 DECLARE_FLAG(bool, trace_irregexp);
+DECLARE_FLAG(int, inlining_hotness);
+DECLARE_FLAG(int, inlining_size_threshold);
+DECLARE_FLAG(int, inlining_callee_size_threshold);
+DECLARE_FLAG(int, inline_getters_setters_smaller_than);
+DECLARE_FLAG(int, inlining_depth_threshold);
+DECLARE_FLAG(int, inlining_caller_size_threshold);
+DECLARE_FLAG(int, inlining_constant_arguments_max_size_threshold);
+DECLARE_FLAG(int, inlining_constant_arguments_min_size_threshold);
+
 
 #ifdef DART_PRECOMPILER
 
 class DartPrecompilationPipeline : public DartCompilationPipeline {
  public:
   explicit DartPrecompilationPipeline(Zone* zone,
                                       FieldTypeMap* field_map = NULL)
       : zone_(zone), result_type_(CompileType::None()), field_map_(field_map) {}
 
   virtual void FinalizeCompilation(FlowGraph* flow_graph) {
@@ skipping 89 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PrecompileParsedFunctionHelper);
 };
 
 
 static void Jump(const Error& error) {
   Thread::Current()->long_jump_base()->Jump(1, error);
 }
 
 
+TypeRangeCache::TypeRangeCache(Precompiler* precompiler,
+                               Thread* thread,
+                               intptr_t num_cids)
+    : precompiler_(precompiler),
+      thread_(thread),
+      lower_limits_(thread->zone()->Alloc<intptr_t>(num_cids)),
+      upper_limits_(thread->zone()->Alloc<intptr_t>(num_cids)) {
+  for (intptr_t i = 0; i < num_cids; i++) {
+    lower_limits_[i] = kNotComputed;
+    upper_limits_[i] = kNotComputed;
+  }
+  ASSERT(precompiler->type_range_cache() == NULL);
+  precompiler->set_type_range_cache(this);
+}
+
+
+TypeRangeCache::~TypeRangeCache() {
+  ASSERT(precompiler_->type_range_cache() == this);
+  precompiler_->set_type_range_cache(NULL);
+}
+
+
 RawError* Precompiler::CompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[],
-    bool reset_fields) {
+    bool reset_fields,
+    uint8_t* jit_feedback,
+    intptr_t jit_feedback_length) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Precompiler precompiler(Thread::Current(), reset_fields);
+    precompiler.LoadFeedback(jit_feedback, jit_feedback_length);
     precompiler.DoCompileAll(embedder_entry_points);
     return Error::null();
   } else {
     Thread* thread = Thread::Current();
     const Error& error = Error::Handle(thread->sticky_error());
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
@@ skipping 83 matching lines @@
   upper_limits_[type_cid] = *upper_limit;
   return true;
 }
 
 
 Precompiler::Precompiler(Thread* thread, bool reset_fields)
     : thread_(thread),
       zone_(NULL),
       isolate_(thread->isolate()),
       reset_fields_(reset_fields),
+      jit_feedback_(NULL),
       changed_(false),
       function_count_(0),
       class_count_(0),
       selector_count_(0),
       dropped_function_count_(0),
       dropped_field_count_(0),
       dropped_class_count_(0),
       dropped_typearg_count_(0),
       dropped_type_count_(0),
       dropped_library_count_(0),
       libraries_(GrowableObjectArray::Handle(I->object_store()->libraries())),
       pending_functions_(
           GrowableObjectArray::Handle(GrowableObjectArray::New())),
       sent_selectors_(),
       enqueued_functions_(),
       fields_to_retain_(),
       functions_to_retain_(),
       classes_to_retain_(),
       typeargs_to_retain_(),
       types_to_retain_(),
       consts_to_retain_(),
       field_type_map_(),
+      type_range_cache_(NULL),
       error_(Error::Handle()),
       get_runtime_type_is_unique_(false) {}
 
 
+void Precompiler::LoadFeedback(uint8_t* buffer, intptr_t length) {
+  if (buffer == NULL) {
+    if (FLAG_trace_precompiler) {
+      THR_Print("Precompiler running without JIT feedback\n");
+    }
+
+    // Flags affecting compilation only:
+    // There is no counter feedback in precompilation, so ignore the counter
+    // when making inlining decisions.
+    FLAG_inlining_hotness = 0;
+    // Use smaller thresholds in precompilation as we are compiling everything
+    // with the optimizing compiler instead of only hot functions.
+    FLAG_inlining_size_threshold = 5;
+    FLAG_inline_getters_setters_smaller_than = 5;
+    FLAG_inlining_callee_size_threshold = 20;
+    FLAG_inlining_depth_threshold = 4;
+    FLAG_inlining_caller_size_threshold = 1000;
+    FLAG_inlining_constant_arguments_max_size_threshold = 100;
+    FLAG_inlining_constant_arguments_min_size_threshold = 30;
+    return;
+  }
+
+  if (FLAG_trace_precompiler) {
+    THR_Print("Loading JIT feedback\n");
+  }
+
+  JSONParser parser(reinterpret_cast<const char*>(buffer), length,
+                    Thread::Current()->zone());
+  ParsedJSONValue* root = parser.ParseValue();
+  if (root->IsError()) {
+    ParsedJSONError* error = static_cast<ParsedJSONError*>(root);
+    THR_Print("Error parsing JIT feedback: %s:%" Pd "\n", error->message(),
+              error->position());
+  } else if (!root->IsObject()) {
+    THR_Print("Error parsing JIT feedback: object expected\n");
+  } else {
+    jit_feedback_ = static_cast<ParsedJSONObject*>(root);
+  }
+}
+
+
 void Precompiler::DoCompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[]) {
   ASSERT(I->compilation_allowed());
 
   {
     StackZone stack_zone(T);
     zone_ = stack_zone.GetZone();
 
     {
       HANDLESCOPE(T);
       // Make sure class hierarchy is stable before compilation so that CHA
       // can be used. Also ensures lookup of entry points won't miss functions
       // because their class hasn't been finalized yet.
       FinalizeAllClasses();
 
       SortClasses();
-      TypeRangeCache trc(T, I->class_table()->NumCids());
+      TypeRangeCache trc(this, T, I->class_table()->NumCids());
+      VerifyJITFeedback();
 
       // Precompile static initializers to compute result type information.
       PrecompileStaticInitializers();
 
       // Precompile constructors to compute type information for final fields.
       ClearAllCode();
       PrecompileConstructors();
 
       for (intptr_t round = 0; round < FLAG_precompiler_rounds; round++) {
         if (FLAG_trace_precompiler) {
@@ skipping 121 matching lines @@
     }
 
    private:
     Array& fields_;
     Field& field_;
     Function& function_;
   };
 
   HANDLESCOPE(T);
   StaticInitializerVisitor visitor(Z);
-  VisitClasses(&visitor);
+  ProgramVisitor::VisitClasses(&visitor);
 }
 
 
 void Precompiler::PrecompileConstructors() {
   class ConstructorVisitor : public FunctionVisitor {
    public:
     explicit ConstructorVisitor(Precompiler* precompiler, Zone* zone)
         : precompiler_(precompiler), zone_(zone) {}
     void Visit(const Function& function) {
       if (!function.IsGenerativeConstructor()) return;
       if (function.HasCode()) {
         // Const constructors may have been visited before. Recompile them here
         // to collect type information for final fields for them as well.
         function.ClearCode();
       }
       if (FLAG_trace_precompiler) {
         THR_Print("Precompiling constructor %s\n", function.ToCString());
       }
       CompileFunction(precompiler_, Thread::Current(), zone_, function,
                       precompiler_->field_type_map());
     }
 
    private:
     Precompiler* precompiler_;
     Zone* zone_;
   };
 
   HANDLESCOPE(T);
   ConstructorVisitor visitor(this, zone_);
-  VisitFunctions(&visitor);
+  ProgramVisitor::VisitFunctions(&visitor);
 
   FieldTypeMap::Iterator it(field_type_map_.GetIterator());
   for (FieldTypePair* current = it.Next(); current != NULL;
        current = it.Next()) {
     const intptr_t cid = current->cid_;
     current->field_->set_guarded_cid(cid);
     current->field_->set_is_nullable(cid == kNullCid || cid == kDynamicCid);
     if (FLAG_trace_precompiler) {
       THR_Print(
           "Field %s <- Type %s\n", current->field_->ToCString(),
           Class::Handle(T->isolate()->class_table()->At(cid)).ToCString());
     }
   }
 }
 
 
 void Precompiler::ClearAllCode() {
   class ClearCodeFunctionVisitor : public FunctionVisitor {
     void Visit(const Function& function) {
       function.ClearCode();
       function.ClearICDataArray();
     }
   };
   ClearCodeFunctionVisitor function_visitor;
-  VisitFunctions(&function_visitor);
+  ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
-  VisitClasses(&class_visitor);
+  ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 
 void Precompiler::AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]) {
   // Note that <rootlibrary>.main is not a root. The appropriate main will be
   // discovered through _getMainClosure.
 
   AddSelector(Symbols::NoSuchMethod());
 
   AddSelector(Symbols::Call());  // For speed, not correctness.
@@ skipping 1521 matching lines @@
 
    private:
     Code& code_;
     Array& table_;
     Smi& pc_offset_;
     Function& target_;
     Code& target_code_;
   };
 
   BindStaticCallsVisitor visitor(Z);
-  VisitFunctions(&visitor);
+  ProgramVisitor::VisitFunctions(&visitor);
 }
 
 
 void Precompiler::SwitchICCalls() {
 #if !defined(TARGET_ARCH_DBC)
   // Now that all functions have been compiled, we can switch to an instance
   // call sequence that loads the Code object and entry point directly from
   // the ic data array instead indirectly through a Function in the ic data
   // array. Iterate all the object pools and rewrite the ic data from
   // (cid, target function, count) to (cid, target code, entry point), and
@@ skipping 68 matching lines @@
     ICData& ic_;
     String& target_name_;
     Array& args_descriptor_;
     UnlinkedCall& unlinked_;
     Code& target_code_;
     UnlinkedCallSet canonical_unlinked_calls_;
   };
 
   ASSERT(!I->compilation_allowed());
   SwitchICCallsVisitor visitor(Z);
-  VisitFunctions(&visitor);
+  ProgramVisitor::VisitFunctions(&visitor);
 #endif
 }
 
 
 void Precompiler::ShareMegamorphicBuckets() {
   const GrowableObjectArray& table = GrowableObjectArray::Handle(
       Z, I->object_store()->megamorphic_cache_table());
   if (table.IsNull()) return;
   MegamorphicCache& cache = MegamorphicCache::Handle(Z);
 
@@ skipping 52 matching lines @@
 
    private:
     Zone* zone_;
     StackMapSet canonical_stackmaps_;
     Code& code_;
     Array& stackmaps_;
     StackMap& stackmap_;
   };
 
   DedupStackMapsVisitor visitor(Z);
-  VisitFunctions(&visitor);
+  ProgramVisitor::VisitFunctions(&visitor);
 }
 
 
 void Precompiler::DedupLists() {
   class DedupListsVisitor : public FunctionVisitor {
    public:
     explicit DedupListsVisitor(Zone* zone)
         : zone_(zone),
           canonical_lists_(),
           code_(Code::Handle(zone)),
@@ skipping 46 matching lines @@
     }
 
    private:
     Zone* zone_;
     ArraySet canonical_lists_;
     Code& code_;
     Array& list_;
   };
 
   DedupListsVisitor visitor(Z);
-  VisitFunctions(&visitor);
+  ProgramVisitor::VisitFunctions(&visitor);
 }
 
 
 void Precompiler::DedupInstructions() {
   class DedupInstructionsVisitor : public FunctionVisitor {
    public:
     explicit DedupInstructionsVisitor(Zone* zone)
         : zone_(zone),
           canonical_instructions_set_(),
           code_(Code::Handle(zone)),
@@ skipping 25 matching lines @@
     }
 
    private:
     Zone* zone_;
     InstructionsSet canonical_instructions_set_;
     Code& code_;
     Instructions& instructions_;
   };
 
   DedupInstructionsVisitor visitor(Z);
-  VisitFunctions(&visitor);
+  ProgramVisitor::VisitFunctions(&visitor);
 }
 
 
-void Precompiler::VisitClasses(ClassVisitor* visitor) {
-  Library& lib = Library::Handle(Z);
-  Class& cls = Class::Handle(Z);
-
-  for (intptr_t i = 0; i < libraries_.Length(); i++) {
-    lib ^= libraries_.At(i);
-    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
-    while (it.HasNext()) {
-      cls = it.GetNextClass();
-      if (cls.IsDynamicClass()) {
-        continue;  // class 'dynamic' is in the read-only VM isolate.
-      }
-      visitor->Visit(cls);
-    }
-  }
-}
-
-
-void Precompiler::VisitFunctions(FunctionVisitor* visitor) {
-  Library& lib = Library::Handle(Z);
-  Class& cls = Class::Handle(Z);
-  Array& functions = Array::Handle(Z);
-  Array& fields = Array::Handle(Z);
-  Field& field = Field::Handle(Z);
-  Object& object = Object::Handle(Z);
-  Function& function = Function::Handle(Z);
-  GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
-
-  for (intptr_t i = 0; i < libraries_.Length(); i++) {
-    lib ^= libraries_.At(i);
-    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
-    while (it.HasNext()) {
-      cls = it.GetNextClass();
-      if (cls.IsDynamicClass()) {
-        continue;  // class 'dynamic' is in the read-only VM isolate.
-      }
-
-      functions = cls.functions();
-      for (intptr_t j = 0; j < functions.Length(); j++) {
-        function ^= functions.At(j);
-        visitor->Visit(function);
-        if (function.HasImplicitClosureFunction()) {
-          function = function.ImplicitClosureFunction();
-          visitor->Visit(function);
-        }
-      }
-
-      functions = cls.invocation_dispatcher_cache();
-      for (intptr_t j = 0; j < functions.Length(); j++) {
-        object = functions.At(j);
-        if (object.IsFunction()) {
-          function ^= functions.At(j);
-          visitor->Visit(function);
-        }
-      }
-      fields = cls.fields();
-      for (intptr_t j = 0; j < fields.Length(); j++) {
-        field ^= fields.At(j);
-        if (field.is_static() && field.HasPrecompiledInitializer()) {
-          function ^= field.PrecompiledInitializer();
-          visitor->Visit(function);
-        }
-      }
-    }
-  }
-  closures = isolate()->object_store()->closure_functions();
-  for (intptr_t j = 0; j < closures.Length(); j++) {
-    function ^= closures.At(j);
-    visitor->Visit(function);
-    ASSERT(!function.HasImplicitClosureFunction());
-  }
-}
-
-
 void Precompiler::FinalizeAllClasses() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     if (!lib.Loaded()) {
       String& uri = String::Handle(Z, lib.url());
       String& msg = String::Handle(
           Z,
@@ skipping 153 matching lines @@
     }
   }
 
 #if defined(DEBUG)
   I->class_table()->Validate();
   I->heap()->Verify();
 #endif
 }
 
 
+void Precompiler::VerifyJITFeedback() {
+  if (jit_feedback_ == NULL) return;
+
+  ParsedJSONString* js_vmversion = jit_feedback_->StringAt("vmVersion");
+  if ((js_vmversion == NULL) ||
+      strcmp(js_vmversion->value(), Version::CommitString()) != 0) {
+    THR_Print(
+        "JIT feedback contains invalid vm version "
+        "(saw %s, expected %s).\n",
+        js_vmversion->value(), Version::CommitString());
+    jit_feedback_ = NULL;
+    return;
+  }
+  ParsedJSONBoolean* js_asserts = jit_feedback_->BooleanAt("asserts");
+  if ((js_asserts == NULL) || (FLAG_enable_asserts != js_asserts->value())) {
+    THR_Print("JIT feedback contains invalid FLAG_enable_asserts\n");
+    jit_feedback_ = NULL;
+    return;
+  }
+  ParsedJSONBoolean* js_typechecks = jit_feedback_->BooleanAt("typeChecks");
+  if ((js_typechecks == NULL) ||
+      (FLAG_enable_type_checks != js_typechecks->value())) {
+    THR_Print("JIT feedback contains invalid FLAG_enable_type_checks\n");
+    jit_feedback_ = NULL;
+    return;
+  }
+
+  ParsedJSONArray* js_scripts = jit_feedback_->ArrayAt("scripts");
+  ASSERT(js_scripts != NULL);
+  Script& script = Script::Handle(Z);
+  for (intptr_t i = 0; i < js_scripts->Length(); i++) {
+    ParsedJSONObject* js_script = js_scripts->ObjectAt(i);
+    ASSERT(js_script != NULL);
+    ParsedJSONString* js_uri = js_script->StringAt("uri");
+    ASSERT(js_uri != NULL);
+    ParsedJSONNumber* js_fp = js_script->NumberAt("checksum");
+    ASSERT(js_fp != NULL);
+    script = LookupScript(js_uri->value());
+    if (script.IsNull()) {
+      THR_Print("Cannot find script %s\n", js_uri->value());
+      continue;
+    }
+    intptr_t fp = script.SourceFingerprint();
+    if (fp != js_fp->value()) {
+      THR_Print(
+          "Fingerprint has changed for %s. Continuing without JIT "
+          "feedback.\n",
+          js_uri->value());
+      jit_feedback_ = NULL;
+      return;
+    }
+  }
+
+  ParsedJSONArray* js_classes = jit_feedback_->ArrayAt("classes");
+  ASSERT(js_classes != NULL);
+  Library& lib = Library::Handle(Z);
+  Class& cls = Class::Handle(Z);
+  String& str = String::Handle(Z);
+  for (intptr_t i = 0; i < js_classes->Length(); i++) {
+    ParsedJSONObject* js_class = js_classes->ObjectAt(i);
+    ASSERT(js_class != NULL);
+    ParsedJSONString* js_uri = js_class->StringAt("uri");
+    ASSERT(js_uri != NULL);
+    ParsedJSONString* js_name = js_class->StringAt("name");
+    ASSERT(js_name != NULL);
+    ParsedJSONNumber* js_cid = js_class->NumberAt("cid");
+    ASSERT(js_cid != NULL);
+
+    str = String::New(js_uri->value());
+    lib = Library::LookupLibrary(T, str);
+    if (lib.IsNull()) {
+      THR_Print("Cannot find library %s\n", js_uri->value());
+      continue;
+    }
+    str = String::New(js_name->value());
+    if (str.Equals(Symbols::TopLevel())) {
+      cls = lib.toplevel_class();
+    } else {
+      cls = lib.LookupClassAllowPrivate(str);
+    }
+    if (cls.IsNull()) {
+      THR_Print("Missing class %s\n", js_name->value());
+      continue;
+    }
+
+    feedback_cid_map_.Insert(IntptrPair(js_cid->value(), cls.id()));
+  }
+
+  ParsedJSONArray* js_functions = jit_feedback_->ArrayAt("functions");
+  ASSERT(js_functions != NULL);
+  for (intptr_t i = 0; i < js_functions->Length(); i++) {
+    ParsedJSONObject* js_function = js_functions->ObjectAt(i);
+    ASSERT(js_function != NULL);
+    ParsedJSONString* js_name = js_function->StringAt("name");
+    ASSERT(js_name != NULL);
+    ParsedJSONNumber* js_cid = js_function->NumberAt("class");
+    ASSERT(js_cid != NULL);
+    ParsedJSONNumber* js_token = js_function->NumberAt("tokenPos");
+    ASSERT(js_token != NULL);
+    ParsedJSONNumber* js_kind = js_function->NumberAt("kind");
+    ASSERT(js_kind != NULL);
+    function_feedback_map_.Insert(FunctionFeedbackPair(
+        FunctionFeedbackKey(MapCid(js_cid->value()), js_token->value(),
+                            js_kind->value()),
+        js_function));
+  }
+
+  class ApplyUsageVisitor : public FunctionVisitor {
+   public:
+    explicit ApplyUsageVisitor(Precompiler* precompiler)
+        : precompiler_(precompiler) {}
+    void Visit(const Function& function) {
+      ParsedJSONObject* js_function = precompiler_->LookupFeedback(function);
+      if (js_function == NULL) {
+        function.set_usage_counter(0);
+      } else {
+        ParsedJSONNumber* js_usage = js_function->NumberAt("usageCounter");
+        ASSERT(js_usage != NULL);
+        function.set_usage_counter(js_usage->value());
+      }
+    }
+
+   private:
+    Precompiler* precompiler_;
+  };
+
+  ApplyUsageVisitor visitor(this);
+  ProgramVisitor::VisitFunctions(&visitor);
+}
+
+
+ParsedJSONObject* Precompiler::LookupFeedback(const Function& function) {
+  const Class& owner = Class::Handle(Z, function.Owner());
+
+  FunctionFeedbackKey key(owner.id(), function.token_pos().value(),
+                          function.kind());
+  FunctionFeedbackPair* pair = function_feedback_map_.Lookup(key);
+  if (pair == NULL) {
+    return NULL;
+  }
+  return pair->value_;
+}
+
+
+RawScript* Precompiler::LookupScript(const char* uri) {
+  String& dart_uri = String::Handle(Z, String::New(uri));
+  Library& lib = Library::Handle(Z);
+  Script& script = Script::Handle(Z);
+  for (intptr_t i = 0; i < libraries_.Length(); i++) {
+    lib ^= libraries_.At(i);
+    script = lib.LookupScript(dart_uri);
+    if (!script.IsNull()) {
+      return script.raw();
+    }
+  }
+  return Script::null();
+}
+
+
+intptr_t Precompiler::MapCid(intptr_t feedback_cid) {
+  if (feedback_cid < kNumPredefinedCids) {
+    return feedback_cid;
+  }
+  IntptrPair* pair = feedback_cid_map_.Lookup(feedback_cid);
+  if (pair == NULL) return kIllegalCid;
+  return pair->value_;
+}
+
+
+void Precompiler::PopulateWithICData(const Function& function,
+                                     FlowGraph* graph) {
+  Zone* zone = Thread::Current()->zone();
+
+  for (BlockIterator block_it = 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);
+        }
+      } else if (instr->IsStaticCall()) {
+        StaticCallInstr* call = instr->AsStaticCall();
+        if (!call->HasICData()) {
+          const Array& arguments_descriptor = Array::Handle(
+              zone, ArgumentsDescriptor::New(call->ArgumentCount(),
+                                             call->argument_names()));
+          const Function& target = call->function();
+          MethodRecognizer::Kind recognized_kind =
+              MethodRecognizer::RecognizeKind(target);
+          int num_args_checked = 0;
+          switch (recognized_kind) {
+            case MethodRecognizer::kDoubleFromInteger:
+            case MethodRecognizer::kMathMin:
+            case MethodRecognizer::kMathMax:
+              num_args_checked = 2;
+              break;
+            default:
+              break;
+          }
+          const ICData& ic_data = ICData::ZoneHandle(
+              zone, ICData::New(function, String::Handle(zone, target.name()),
+                                arguments_descriptor, call->deopt_id(),
+                                num_args_checked, true));
+          ic_data.AddTarget(target);
+          call->set_ic_data(&ic_data);
+        }
+      }
+    }
+  }
+}
+
+
+void Precompiler::TryApplyFeedback(const Function& function, FlowGraph* graph) {
+  ParsedJSONObject* js_function = LookupFeedback(function);
+  if (js_function == NULL) {
+    if (FLAG_trace_precompiler) {
+      THR_Print("No feedback available for %s\n",
+                function.ToQualifiedCString());
+    }
+    return;
+  }
+
+  ParsedJSONArray* js_icdatas = js_function->ArrayAt("ics");
+  ASSERT(js_icdatas != NULL);
+
+  for (BlockIterator block_it = 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();
+        TryApplyFeedback(js_icdatas, *call->ic_data());
+      } else if (instr->IsStaticCall()) {
+        StaticCallInstr* call = instr->AsStaticCall();
+        TryApplyFeedback(js_icdatas, *call->ic_data());
+      }
+    }
+  }
+}
+
+
+void Precompiler::TryApplyFeedback(ParsedJSONArray* js_icdatas,
+                                   const ICData& ic) {
+  for (intptr_t j = 0; j < js_icdatas->Length(); j++) {
+    ParsedJSONObject* js_icdata = js_icdatas->ObjectAt(j);
+    ASSERT(js_icdata != NULL);
+
+    ParsedJSONNumber* js_deoptid = js_icdata->NumberAt("deoptId");
+    ASSERT(js_deoptid != NULL);
+    if (js_deoptid->value() != ic.deopt_id()) continue;
+
+    ParsedJSONBoolean* js_isstaticcall = js_icdata->BooleanAt("isStaticCall");
+    ASSERT(js_isstaticcall != NULL);
+    if (js_isstaticcall->value() != ic.is_static_call()) return;
+
+    ParsedJSONNumber* js_argsTested = js_icdata->NumberAt("argsTested");
+    ASSERT(js_argsTested != NULL);
+    if (js_argsTested->value() != ic.NumArgsTested()) return;
+
+    ParsedJSONString* js_selector = js_icdata->StringAt("selector");
+    ASSERT(js_selector != NULL);
+    const String& feedback_selector =
+        String::Handle(String::New(js_selector->value()));
+    const String& selector = String::Handle(ic.target_name());
+    // N.B.: EqualsIgnoringPrivateKey is not symmetric.
+    if (!String::EqualsIgnoringPrivateKey(selector, feedback_selector)) return;
+
+    ParsedJSONArray* js_entries = js_icdata->ArrayAt("entries");
+    ASSERT(js_entries != NULL);
+    if (ic.is_static_call()) {
+      // [cid [cid]] target count
+      ParsedJSONNumber* entry = js_entries->NumberAt(js_entries->Length() - 1);
+      ASSERT(entry != NULL);
+      ic.SetCountAt(0, entry->value());
+    } else {
+      // [cid [cid [cid]]] target count
+      const Array& arguments_descriptor =
+          Array::Handle(ic.arguments_descriptor());
+      ArgumentsDescriptor args_desc(arguments_descriptor);
+
+      intptr_t num_args_checked = ic.NumArgsTested();
+      for (intptr_t k = 0; k < js_entries->Length();
+           k += num_args_checked + 1) {
+        GrowableArray<intptr_t> class_ids(num_args_checked);
+        for (intptr_t arg = 0; arg < num_args_checked; arg++) {
+          ParsedJSONNumber* entry = js_entries->NumberAt(k + arg);
+          ASSERT(entry != NULL);
+          class_ids.Add(MapCid(entry->value()));
+        }
+        ParsedJSONNumber* entry = js_entries->NumberAt(k + num_args_checked);
+        ASSERT(entry != NULL);
+        intptr_t count = entry->value();
+
+        bool has_missing_cid = false;
+        for (intptr_t arg = 0; arg < num_args_checked; arg++) {
+          if (class_ids[arg] == kIllegalCid) {
+            has_missing_cid = true;
+          }
+        }
+        if (has_missing_cid) continue;
+
+        intptr_t receiver_cid = class_ids[0];
+        const Class& receiver_cls =
+            Class::Handle(I->class_table()->At(receiver_cid));
+        if (receiver_cls.IsClass()) {
+          const Function& target =
+              Function::Handle(Resolver::ResolveDynamicForReceiverClass(
+                  receiver_cls, selector, args_desc, false));
+          // TODO(rmacnak): Create missing dispatchers.
+          if (!target.IsNull()) {
+            if (num_args_checked == 1) {
+              ic.AddReceiverCheck(receiver_cid, target, count);
+            } else {
+              ic.AddCheck(class_ids, target, count);
+            }
+          }
+        }
+      }
+    }
+
+    return;
+  }
+}
+
+
 void Precompiler::ResetPrecompilerState() {
   changed_ = false;
   function_count_ = 0;
   class_count_ = 0;
   selector_count_ = 0;
   dropped_function_count_ = 0;
   dropped_field_count_ = 0;
   ASSERT(pending_functions_.Length() == 0);
   sent_selectors_.Clear();
   enqueued_functions_.Clear();
@@ skipping 130 matching lines @@
         ZoneGrowableArray<const ICData*>* ic_data_array =
             new (zone) ZoneGrowableArray<const ICData*>();
 #ifndef PRODUCT
         TimelineDurationScope tds(thread(), compiler_timeline,
                                   "BuildFlowGraph");
 #endif  // !PRODUCT
         flow_graph = pipeline->BuildFlowGraph(
             zone, parsed_function(), *ic_data_array, Compiler::kNoOSRDeoptId);
       }
 
+      if (optimized()) {
+        Precompiler::PopulateWithICData(parsed_function()->function(),
+                                        flow_graph);
+        if (precompiler_ != NULL) {
+          precompiler_->TryApplyFeedback(parsed_function()->function(),
+                                         flow_graph);
+        }
+      }
+
       const bool print_flow_graph =
           (FLAG_print_flow_graph ||
            (optimized() && FLAG_print_flow_graph_optimized)) &&
           FlowGraphPrinter::ShouldPrint(function);
 
       if (print_flow_graph) {
         FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
       }
 
       if (optimized()) {
@@ skipping 30 matching lines @@
         // is that the length of |inline_id_to_function| is always larger
         // than the length of |inline_id_to_token_pos| by one.
         // Top scope function has no caller (-1). We do this because we expect
         // all token positions to be at an inlined call.
         // Top scope function has no caller (-1).
         caller_inline_id.Add(-1);
         CSTAT_TIMER_SCOPE(thread(), graphoptimizer_timer);
 
         AotOptimizer optimizer(precompiler_, flow_graph,
                                use_speculative_inlining, &inlining_black_list);
-        optimizer.PopulateWithICData();
 
         optimizer.ApplyClassIds();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         FlowGraphTypePropagator::Propagate(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         optimizer.ApplyICData();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
@@ skipping 478 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart