Use off-heap data for type feedback in PolymorphicInstanceCallInstr

runtime/vm/flow_graph_compiler.h

 // Copyright (c) 2012, 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.
 
 #ifndef RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 #define RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_descriptors.h"
@@ skipping 215 matching lines @@
  private:
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) = 0;
 
   Label entry_label_;
   Label exit_label_;
 
   DISALLOW_COPY_AND_ASSIGN(SlowPathCode);
 };
 
 
-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 {
    public:
     BlockInfo()
         : block_label_(),
           jump_label_(&block_label_),
           next_nonempty_label_(NULL),
           is_marked_(false) {}
 
@@ skipping 165 matching lines @@
                                  TokenPosition token_pos,
                                  LocationSummary* locs);
 
   void EmitInstanceCall(const StubEntry& stub_entry,
                         const ICData& ic_data,
                         intptr_t argument_count,
                         intptr_t deopt_id,
                         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,
                                    LocationSummary* locs,
                                    intptr_t try_index,
                                    intptr_t slow_path_argument_count = 0);
 
   void EmitSwitchableInstanceCall(const ICData& ic_data,
                                   intptr_t argument_count,
                                   intptr_t deopt_id,
                                   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,
                        Label* match_found,
                        intptr_t deopt_id,
                        TokenPosition token_index,
                        LocationSummary* locs,
                        bool complete,
                        intptr_t total_ic_calls);
 
@@ skipping 122 matching lines @@
   const ICData* GetOrAddInstanceCallICData(intptr_t deopt_id,
                                            const String& target_name,
                                            const Array& arguments_descriptor,
                                            intptr_t num_args_tested);
 
   const ICData* GetOrAddStaticCallICData(intptr_t deopt_id,
                                          const Function& target,
                                          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_;
   }
 
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return thread_->isolate(); }
   Zone* zone() const { return zone_; }
 
   void AddStubCallTarget(const Code& code);
 
   RawArray* edge_counters_array() const { return edge_counters_array_.raw(); }
 
   RawArray* InliningIdToFunction() const;
 
   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,
     kNoResult,
   };
   void RecordAfterCallHelper(TokenPosition token_pos,
                              intptr_t deopt_id,
                              intptr_t argument_count,
                              CallResult result,
                              LocationSummary* locs);
@@ skipping 25 matching lines @@
                                LocationSummary* locs);
 
   void EmitUnoptimizedStaticCall(intptr_t argument_count,
                                  intptr_t deopt_id,
                                  TokenPosition token_pos,
                                  LocationSummary* locs,
                                  const ICData& ic_data);
 
   // 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,
+                                           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();
+
+  // Returns new class-id bias.
+  int EmitTestAndCallCheckCid(Label* next_label,
+                              const CidRangeTarget& target,
+                              int bias);
 
 // DBC handles type tests differently from all other architectures due
 // to its interpreted nature.
 #if !defined(TARGET_ARCH_DBC)
   // Type checking helper methods.
   void CheckClassIds(Register class_id_reg,
                      const GrowableArray<intptr_t>& class_ids,
                      Label* is_instance_lbl,
                      Label* is_not_instance_lbl);
 
@@ skipping 155 matching lines @@
   ZoneGrowableArray<const ICData*>* deopt_id_to_ic_data_;
 
   Array& edge_counters_array_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphCompiler);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_FLOW_GRAPH_COMPILER_H_