Use off-heap data for type feedback in PolymorphicInstanceCallInstr

runtime/vm/flow_graph_compiler.h

Index: runtime/vm/flow_graph_compiler.h
diff --git a/runtime/vm/flow_graph_compiler.h b/runtime/vm/flow_graph_compiler.h
index 7262d0e9c03589ab3ea89fe9f7cd40f2a74a2dc7..ed4cf902511868e269973ef336e6b900f623b87b 100644
--- a/runtime/vm/flow_graph_compiler.h
+++ b/runtime/vm/flow_graph_compiler.h
@@ -233,22 +233,6 @@ class SlowPathCode : public ZoneAllocated {
 };
 
 
-struct CidRangeTarget {
-  intptr_t cid_start;
-  intptr_t cid_end;
-  Function* target;
-  intptr_t count;
-  CidRangeTarget(intptr_t cid_start_arg,
-                 intptr_t cid_end_arg,
-                 Function* target_arg,
-                 intptr_t count_arg)
-      : cid_start(cid_start_arg),
-        cid_end(cid_end_arg),
-        target(target_arg),
-        count(count_arg) {}
-};
-
-
 class FlowGraphCompiler : public ValueObject {
  private:
   class BlockInfo : public ZoneAllocated {
@@ -434,17 +418,20 @@ class FlowGraphCompiler : public ValueObject {
                         TokenPosition token_pos,
                         LocationSummary* locs);
 
-  void 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_call_count);
+  void EmitPolymorphicInstanceCall(
+      const CallTargets& targets,
+      const InstanceCallInstr& original_instruction,
+      intptr_t argument_count,
+      const Array& argument_names,
+      intptr_t deopt_id,
+      TokenPosition token_pos,
+      LocationSummary* locs,
+      bool complete,
+      intptr_t total_call_count);
 
   // Pass a value for try-index where block is not available (e.g. slow path).
-  void EmitMegamorphicInstanceCall(const ICData& ic_data,
+  void EmitMegamorphicInstanceCall(const String& function_name,
+                                   const Array& arguments_descriptor,
                                    intptr_t argument_count,
                                    intptr_t deopt_id,
                                    TokenPosition token_pos,
@@ -458,7 +445,8 @@ class FlowGraphCompiler : public ValueObject {
                                   TokenPosition token_pos,
                                   LocationSummary* locs);
 
-  void EmitTestAndCall(const ICData& ic_data,
+  void EmitTestAndCall(const CallTargets& targets,
+                       const String& function_name,
                        intptr_t arg_count,
                        const Array& arg_names,
                        Label* failed,
@@ -601,8 +589,10 @@ class FlowGraphCompiler : public ValueObject {
                                          const Array& arguments_descriptor,
                                          intptr_t num_args_tested);
 
-  static const ICData& TrySpecializeICDataByReceiverCid(const ICData& ic_data,
-                                                        intptr_t cid);
+  static const CallTargets* ResolveCallTargetsForReceiverCid(
+      intptr_t cid,
+      const String& selector,
+      const Array& args_desc_array);
 
   const ZoneGrowableArray<const ICData*>& deopt_id_to_ic_data() const {
     return *deopt_id_to_ic_data_;
@@ -621,6 +611,11 @@ class FlowGraphCompiler : public ValueObject {
   void BeginCodeSourceRange();
   void EndCodeSourceRange(TokenPosition token_pos);
 
+  static bool LookupMethodFor(int class_id,
+                              const String& name,
+                              const ArgumentsDescriptor& args_desc,
+                              Function* fn_return);
+
 #if defined(TARGET_ARCH_DBC)
   enum CallResult {
     kHasResult,
@@ -666,9 +661,23 @@ class FlowGraphCompiler : public ValueObject {
 
   // Helper for TestAndCall that calculates a good bias that
   // allows more compact instructions to be emitted.
-  intptr_t ComputeGoodBiasForCidComparison(
-      const GrowableArray<CidRangeTarget>& sorted,
-      intptr_t max_immediate);
+  intptr_t ComputeGoodBiasForCidComparison(const CallTargets& sorted,

[Vyacheslav Egorov (Google), 2017/04/20 16:45:33]

it might be good to just package this and all other related helpers into a
single separate class called: 

class TestAndCallEmitter {
 public:

 private:
  LoadReceiver();
  LoadCid();
  ...
};

the compiler class is already gigantic. 

However if you don't feel like it - feel free to ignore.

[erikcorry, 2017/04/21 13:04:43]

Two of these methods were just eliminated, so I chose not to do this change.

+                                           intptr_t max_immediate);
+
+  // More helpers for EmitTestAndCall.
+  void EmitTestAndCallLoadReceiver(intptr_t argument_count,
+                                   const Array& arguments_descriptor);
+
+  void EmitTestAndCallSmiBranch(Label* label, bool if_smi);
+
+  void EmitTestAndCallLoadCid(int bias);
+
+  // Returns new class-id bias.
+  int EmitTestAndCallCheckCid(Label* next_label,
+                              const CidRangeTarget& target,
+                              int bias);
+
+  void EmitTestAndCallGotoMatchFound(Label* match_found);
 
 // DBC handles type tests differently from all other architectures due
 // to its interpreted nature.