Use off-heap data for type feedback in PolymorphicInstanceCallInstr

runtime/vm/flow_graph_compiler.cc

Index: runtime/vm/flow_graph_compiler.cc
diff --git a/runtime/vm/flow_graph_compiler.cc b/runtime/vm/flow_graph_compiler.cc
index 866cab4de2588fd832ce9d9a245ef424aee606ec..4869aeb82e479e5872b4acb66600cea7fb86a261 100644
--- a/runtime/vm/flow_graph_compiler.cc
+++ b/runtime/vm/flow_graph_compiler.cc
@@ -23,6 +23,7 @@
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/raw_object.h"
+#include "vm/resolver.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
@@ -1169,8 +1170,12 @@ void FlowGraphCompiler::GenerateInstanceCall(intptr_t deopt_id,
   }
 
   if (is_optimizing()) {
-    EmitMegamorphicInstanceCall(ic_data_in, argument_count, deopt_id, token_pos,
-                                locs, CatchClauseNode::kInvalidTryIndex);
+    String& name = String::Handle(ic_data_in.target_name());
+    Array& arguments_descriptor =
+        Array::Handle(ic_data_in.arguments_descriptor());
+    EmitMegamorphicInstanceCall(name, arguments_descriptor, argument_count,
+                                deopt_id, token_pos, locs,
+                                CatchClauseNode::kInvalidTryIndex);
     return;
   }
 
@@ -1646,9 +1651,9 @@ static int LowestCidFirst(const CidRangeTarget* a, const CidRangeTarget* b) {
 // The expected number of elements to sort is less than 10.
 void FlowGraphCompiler::SortICDataByCount(
     const ICData& ic_data,
-    GrowableArray<CidRangeTarget>* sorted_arg,
+    ZoneGrowableArray<CidRangeTarget>* sorted_arg,

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

why did this suddenly become ZoneGrowableArray?

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

Undone.

     bool drop_smi) {
-  GrowableArray<CidRangeTarget>& sorted = *sorted_arg;
+  ZoneGrowableArray<CidRangeTarget>& sorted = *sorted_arg;
   ASSERT(ic_data.NumArgsTested() == 1);
   const intptr_t len = ic_data.NumberOfChecks();
   sorted.Clear();
@@ -1787,38 +1792,26 @@ void FlowGraphCompiler::EndCodeSourceRange(TokenPosition token_pos) {
 }
 
 
-const ICData& FlowGraphCompiler::TrySpecializeICDataByReceiverCid(
-    const ICData& ic_data,
+const PolymorphicTargets* FlowGraphCompiler::TrySpecializeByReceiverCid(

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

I think this name now is confusing given that we don't pass ICData here anymore.


Maybe call it:

ResolveCallTargetsForReceiverCid(...)

I also suggest a more natural ordering of the arguments:

(cid, selector, args descriptor)

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

Done.

+    const Array& args_desc_array,
+    const String& selector,
     intptr_t cid) {
   Zone* zone = Thread::Current()->zone();
-  if (ic_data.NumArgsTested() != 1) return ic_data;
 
-  if ((ic_data.NumberOfUsedChecks() == 1) && ic_data.HasReceiverClassId(cid)) {
-    return ic_data;  // Nothing to do
-  }
+  ArgumentsDescriptor args_desc(args_desc_array);
 
-  intptr_t count = 1;
-  const Function& function =
-      Function::Handle(zone, ic_data.GetTargetForReceiverClassId(cid, &count));
-  // TODO(fschneider): Try looking up the function on the class if it is
-  // not found in the ICData.
-  if (!function.IsNull()) {
-    const ICData& new_ic_data = ICData::ZoneHandle(
-        zone, ICData::New(Function::Handle(zone, ic_data.Owner()),
-                          String::Handle(zone, ic_data.target_name()),
-                          Object::empty_array(),  // Dummy argument descriptor.
-                          ic_data.deopt_id(), ic_data.NumArgsTested(), false));
-    new_ic_data.SetDeoptReasons(ic_data.DeoptReasons());
-    new_ic_data.AddReceiverCheck(cid, function, count);
-    return new_ic_data;
-  }
+  Function& fn = Function::Handle(zone);
+  if (!LookupMethodFor(cid, args_desc, selector, &fn)) return NULL;

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

Similar here: natural arguments order should probably be (cid, selector,
args_desc)

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

Done.

 
-  return ic_data;
+  PolymorphicTargets* targets = new (zone) PolymorphicTargets(zone);
+  targets->Add(CidRangeTarget(cid, cid, &fn, 1));

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

this 1 needs a comment, e.g. /*count=*/1

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

Done.

+
+  return targets;
 }
 
 
 intptr_t FlowGraphCompiler::ComputeGoodBiasForCidComparison(
-    const GrowableArray<CidRangeTarget>& sorted,
+    const PolymorphicTargets& sorted,
     intptr_t max_immediate) {
   // Sometimes a bias can be useful so we can emit more compact compare
   // instructions.
@@ -1849,22 +1842,51 @@ intptr_t FlowGraphCompiler::ComputeGoodBiasForCidComparison(
 }
 
 
+bool FlowGraphCompiler::LookupMethodFor(int class_id,
+                                        const ArgumentsDescriptor& args_desc,
+                                        const String& name,
+                                        Function* fn_return) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  Zone* zone = thread->zone();
+  if (class_id < 0) return false;
+  if (class_id >= isolate->class_table()->NumCids()) return false;
+
+  RawClass* raw_class = isolate->class_table()->At(class_id);
+  if (raw_class == NULL) return false;
+  Class& cls = Class::Handle(zone, raw_class);
+  if (cls.IsNull()) return false;
+  if (!cls.is_finalized()) return false;
+  if (Array::Handle(cls.functions()).IsNull()) return false;
+
+  Function& target_function =

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

for named arguments I suggest:

const bool allow_add = false;
..., allow_add)

or 

/*allow_add=*/false.

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

Done.

+      Function::Handle(zone, Resolver::ResolveDynamicForReceiverClass(
+                                 cls, name, args_desc, false /* allow add */));
+  if (target_function.IsNull()) return false;
+  *fn_return ^= target_function.raw();
+  return true;
+}
+
+
 #if !defined(TARGET_ARCH_DBC)
 // DBC emits calls very differently from other architectures due to its
 // interpreted nature.
-void FlowGraphCompiler::EmitPolymorphicInstanceCall(const ICData& ic_data,
-                                                    intptr_t argument_count,
-                                                    const Array& argument_names,
-                                                    intptr_t deopt_id,
-                                                    TokenPosition token_pos,
-                                                    LocationSummary* locs,
-                                                    bool complete,
-                                                    intptr_t total_ic_calls) {
+void FlowGraphCompiler::EmitPolymorphicInstanceCall(
+    const PolymorphicTargets& targets,
+    const InstanceCallInstr& original_call_insn,

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

maybe just original_call instead of original_call_insn

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

Done.

+    intptr_t argument_count,
+    const Array& argument_names,
+    intptr_t deopt_id,
+    TokenPosition token_pos,
+    LocationSummary* locs,
+    bool complete,
+    intptr_t total_ic_calls) {
   if (FLAG_polymorphic_with_deopt) {
     Label* deopt =
         AddDeoptStub(deopt_id, ICData::kDeoptPolymorphicInstanceCallTestFail);
     Label ok;
-    EmitTestAndCall(ic_data, argument_count, argument_names,
+    EmitTestAndCall(targets, original_call_insn.function_name(), argument_count,
+                    argument_names,
                     deopt,  // No cid match.
                     &ok,    // Found cid.
                     deopt_id, token_pos, locs, complete, total_ic_calls);
@@ -1872,14 +1894,17 @@ void FlowGraphCompiler::EmitPolymorphicInstanceCall(const ICData& ic_data,
   } else {
     if (complete) {
       Label ok;
-      EmitTestAndCall(ic_data, argument_count, argument_names,
+      EmitTestAndCall(targets, original_call_insn.function_name(),
+                      argument_count, argument_names,
                       NULL,  // No cid match.
                       &ok,   // Found cid.
                       deopt_id, token_pos, locs, true, total_ic_calls);
       assembler()->Bind(&ok);
     } else {
-      EmitSwitchableInstanceCall(ic_data, argument_count, deopt_id, token_pos,
-                                 locs);
+      const ICData& unary_checks = ICData::ZoneHandle(
+          zone(), original_call_insn.ic_data()->AsUnaryClassChecks());
+      EmitSwitchableInstanceCall(unary_checks, argument_count, deopt_id,
+                                 token_pos, locs);
     }
   }
 }