Add flag polymorphic_with_deopt (default true) and handle case when false: use megamorphic instead …

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"
@@ skipping 12 matching lines @@
 #include "vm/parser.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, always_megamorphic_calls, false,
     "Instance call always as megamorphic.");
-DEFINE_FLAG(bool, trace_inlining_intervals, false,
-    "Inlining interval diagnostics");
 DEFINE_FLAG(bool, enable_simd_inline, true,
     "Enable inlining of SIMD related method calls.");
 DEFINE_FLAG(int, min_optimization_counter_threshold, 5000,
     "The minimum invocation count for a function.");
 DEFINE_FLAG(int, optimization_counter_scale, 2000,
     "The scale of invocation count, by size of the function.");
+DEFINE_FLAG(bool, polymorphic_with_deopt, true,
+    "Polymorphic calls can be generated so that failure either causes "
+    "deoptimization or falls through to a megamorphic call");
 DEFINE_FLAG(bool, source_lines, false, "Emit source line as assembly comment.");
+DEFINE_FLAG(bool, trace_inlining_intervals, false,
+    "Inlining interval diagnostics");
 DEFINE_FLAG(bool, use_megamorphic_stub, true, "Out of line megamorphic lookup");
 
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(bool, deoptimize_alot);
 DECLARE_FLAG(int, deoptimize_every);
 DECLARE_FLAG(charp, deoptimize_filter);
 DECLARE_FLAG(bool, disassemble);
 DECLARE_FLAG(bool, disassemble_optimized);
 DECLARE_FLAG(bool, emit_edge_counters);
 DECLARE_FLAG(bool, ic_range_profiling);
@@ skipping 1610 matching lines @@
   }
   const Array& res = Array::Handle(
       Array::New(inline_id_to_function_.length(), Heap::kOld));
   for (intptr_t i = 0; i < inline_id_to_function_.length(); i++) {
     res.SetAt(i, *inline_id_to_function_[i]);
   }
   return res.raw();
 }
 
 
+void FlowGraphCompiler::EmitPolymorphicInstanceCall(
+    const ICData& ic_data,
+    intptr_t argument_count,
+    const Array& argument_names,
+    intptr_t deopt_id,
+    intptr_t token_pos,
+    LocationSummary* locs) {
+  if (FLAG_polymorphic_with_deopt) {
+    Label* deopt = AddDeoptStub(deopt_id,
+                                ICData::kDeoptPolymorphicInstanceCallTestFail);
+    Label ok;
+    EmitTestAndCall(ic_data, argument_count, argument_names,
+                    deopt,  // No cid match.
+                    &ok,    // Found cid.
+                    deopt_id, token_pos, locs);
+    assembler()->Bind(&ok);
+  } else {
+    // Instead of deoptimizing, do a megamorphic call when no matching
+    // cid found.
+    Label megamorphic, ok;
+    EmitTestAndCall(ic_data, argument_count, argument_names,
+                    &megamorphic,  // No cid match.
+                    &ok,           // Found cid.
+                    deopt_id, token_pos, locs);
+    // Fall through if last test is match.
+    assembler()->Jump(&ok);
+    assembler()->Bind(&megamorphic);
+    EmitMegamorphicInstanceCall(ic_data, argument_count, deopt_id,
+                                token_pos, locs);
+    assembler()->Bind(&ok);
+  }
+}
+
+
 #if defined(DEBUG)
 void FlowGraphCompiler::FrameStateUpdateWith(Instruction* instr) {
   ASSERT(!is_optimizing());
 
   switch (instr->tag()) {
     case Instruction::kPushArgument:
     case Instruction::kPushTemp:
       // Do nothing.
       break;
 
@@ skipping 55 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif
 
 
 }  // namespace dart