Allow dispatch to use a range of Class-ids in tests

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 214 matching lines @@
  private:
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) = 0;
 
   Label entry_label_;
   Label exit_label_;
 
   DISALLOW_COPY_AND_ASSIGN(SlowPathCode);
 };
 
 
-struct CidTarget {
-  intptr_t cid;
+struct CidRangeTarget {
+  intptr_t cid_start;
+  intptr_t cid_end;
   Function* target;
   intptr_t count;
-  CidTarget(intptr_t cid_arg, Function* target_arg, intptr_t count_arg)
-      : cid(cid_arg), target(target_arg), count(count_arg) {}
+  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_),
@@ skipping 169 matching lines @@
                         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);
+                                   bool complete,
+                                   intptr_t total_ic_count);
 
   // Pass a value for try-index where block is not available (e.g. slow path).
   void EmitMegamorphicInstanceCall(const ICData& ic_data,
                                    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,
                        intptr_t arg_count,
                        const Array& arg_names,
                        Label* failed,
                        Label* match_found,
                        intptr_t deopt_id,
                        TokenPosition token_index,
                        LocationSummary* locs,
-                       bool complete);
+                       bool complete,
+                       intptr_t total_ic_calls);
 
   Condition EmitEqualityRegConstCompare(Register reg,
                                         const Object& obj,
                                         bool needs_number_check,
                                         TokenPosition token_pos);
   Condition EmitEqualityRegRegCompare(Register left,
                                       Register right,
                                       bool needs_number_check,
                                       TokenPosition token_pos);
 
@@ skipping 87 matching lines @@
     if (current_block_ == NULL) {
       return CatchClauseNode::kInvalidTryIndex;
     }
     return current_block_->try_index();
   }
 
   bool may_reoptimize() const { return may_reoptimize_; }
 
   // Returns 'sorted' array in decreasing count order.
   static void SortICDataByCount(const ICData& ic_data,
-                                GrowableArray<CidTarget>* sorted,
+                                GrowableArray<CidRangeTarget>* sorted,
                                 bool drop_smi);
 
   // Use in unoptimized compilation to preserve/reuse ICData.
   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,
@@ skipping 29 matching lines @@
                              intptr_t deopt_id,
                              intptr_t argument_count,
                              CallResult result,
                              LocationSummary* locs);
   void RecordAfterCall(Instruction* instr, CallResult result);
 #endif
 
  private:
   friend class CheckStackOverflowSlowPath;  // For pending_deoptimization_env_.
 
-  static bool ShouldInlineSmiStringHashCode(const ICData& ic_data);
-
   void EmitFrameEntry();
 
   void AddStaticCallTarget(const Function& function);
 
   void GenerateDeferredCode();
 
   void EmitInstructionPrologue(Instruction* instr);
   void EmitInstructionEpilogue(Instruction* instr);
 
   // Emit code to load a Value into register 'dst'.
   void LoadValue(Register dst, Value* value);
 
   void EmitOptimizedStaticCall(const Function& function,
                                const Array& arguments_descriptor,
                                intptr_t argument_count,
                                intptr_t deopt_id,
                                TokenPosition token_pos,
                                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 GetGoodBias(const GrowableArray<CidRangeTarget>& sorted,

[Vyacheslav Egorov (Google), 2017/03/10 10:31:30]

ComputeGoodBiasForCidComparison(...)?

[erikcorry, 2017/03/10 13:30:01]

Done.

+                       intptr_t max_immediate);
+
 // 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);
 
   RawSubtypeTestCache* GenerateInlineInstanceof(TokenPosition token_pos,
@@ skipping 153 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_