Use off-heap data for type feedback in PolymorphicInstanceCallInstr

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/locations.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
 #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"
 #include "vm/timeline.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool,
             enable_simd_inline,
             true,
@@ skipping 1126 matching lines @@
             *StubCode::TwoArgsOptimizedCheckInlineCache_entry(), ic_data,
             argument_count, deopt_id, token_pos, locs);
         return;
       default:
         UNIMPLEMENTED();
     }
     return;
   }
 
   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;
   }
 
   switch (ic_data.NumArgsTested()) {
     case 1:
       EmitInstanceCall(*StubCode::OneArgCheckInlineCache_entry(), ic_data,
                        argument_count, deopt_id, token_pos, locs);
       break;
     case 2:
       EmitInstanceCall(*StubCode::TwoArgsCheckInlineCache_entry(), ic_data,
@@ skipping 455 matching lines @@
 static int LowestCidFirst(const CidRangeTarget* a, const CidRangeTarget* b) {
   // Negative if 'a' should sort before 'b'.
   return a->cid_start - b->cid_start;
 }
 
 
 // Returns 'sorted' array in decreasing count order.
 // 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();
 
   for (int i = 0; i < len; i++) {
     intptr_t receiver_cid = ic_data.GetReceiverClassIdAt(i);
     if (drop_smi && (receiver_cid == kSmiCid)) continue;
     Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
     sorted.Add(CidRangeTarget(receiver_cid, receiver_cid, &target,
                               ic_data.GetCountAt(i)));
@@ skipping 118 matching lines @@
   code_source_map_builder_->BeginCodeSourceRange(assembler()->CodeSize());
 }
 
 
 void FlowGraphCompiler::EndCodeSourceRange(TokenPosition token_pos) {
   code_source_map_builder_->EndCodeSourceRange(assembler()->CodeSize(),
                                                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.
   intptr_t min_cid = 1000000;
   intptr_t max_cid = -1;
 
   const intptr_t sorted_len = sorted.length();
 
   for (intptr_t i = 0; i < sorted_len + 1; i++) {
     bool done = (i == sorted_len);
@@ skipping 10 matching lines @@
       }
     }
     min_cid = Utils::Minimum(min_cid, start);
     max_cid = Utils::Maximum(max_cid, end);
   }
   UNREACHABLE();
   return 0;
 }
 
 
+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);
     assembler()->Bind(&ok);
   } 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);
     }
   }
 }
 #endif
 
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 // TODO(vegorov) re-enable frame state tracking on DBC. It is
 // currently disabled because it relies on LocationSummaries and
 // we don't use them during unoptimized compilation on DBC.
 void FlowGraphCompiler::FrameStateUpdateWith(Instruction* instr) {
@@ skipping 61 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif  // defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart