Recognize and optimize a.runtimeType == b.runtimeType pattern.

runtime/vm/flow_graph_inliner.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/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
@@ skipping 811 matching lines @@
                                    param_stubs);
           DEBUG_ASSERT(callee_graph->VerifyUseLists());
         }
 
         {
           CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer);
           // TODO(fschneider): Improve suppression of speculative inlining.
           // Deopt-ids overlap between caller and callee.
           if (FLAG_precompiled_mode) {
 #ifdef DART_PRECOMPILER
-            AotOptimizer optimizer(callee_graph,
+            AotOptimizer optimizer(inliner_->precompiler_,
+                                   callee_graph,
                                    inliner_->use_speculative_inlining_,
                                    inliner_->inlining_black_list_);
             optimizer.PopulateWithICData();
 
             optimizer.ApplyClassIds();
             DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
             FlowGraphTypePropagator::Propagate(callee_graph);
             DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
@@ skipping 1028 matching lines @@
   return FLAG_trace_inlining && FlowGraphPrinter::ShouldPrint(top);
 }
 
 
 FlowGraphInliner::FlowGraphInliner(
     FlowGraph* flow_graph,
     GrowableArray<const Function*>* inline_id_to_function,
     GrowableArray<TokenPosition>* inline_id_to_token_pos,
     GrowableArray<intptr_t>* caller_inline_id,
     bool use_speculative_inlining,
-    GrowableArray<intptr_t>* inlining_black_list)
+    GrowableArray<intptr_t>* inlining_black_list,
+    Precompiler* precompiler)
     : flow_graph_(flow_graph),
       inline_id_to_function_(inline_id_to_function),
       inline_id_to_token_pos_(inline_id_to_token_pos),
       caller_inline_id_(caller_inline_id),
       trace_inlining_(ShouldTraceInlining(flow_graph)),
       use_speculative_inlining_(use_speculative_inlining),
-      inlining_black_list_(inlining_black_list) {
+      inlining_black_list_(inlining_black_list),
+      precompiler_(precompiler) {
   ASSERT(!use_speculative_inlining || (inlining_black_list != NULL));
 }
 
 
 void FlowGraphInliner::CollectGraphInfo(FlowGraph* flow_graph, bool force) {
   const Function& function = flow_graph->function();
   if (force || (function.optimized_instruction_count() == 0)) {
     GraphInfoCollector info;
     info.Collect(*flow_graph);
 
@@ skipping 1852 matching lines @@
           flow_graph->AppendTo(*entry, *last,
                                call->deopt_id() != Thread::kNoDeoptId ?
                                call->env() : NULL,
                                FlowGraph::kValue);
           return true;
         }
       }
       return false;
     }
 
+    case MethodRecognizer::kObjectRuntimeType: {
+      Type& type = Type::Handle(Z);
+      if (RawObject::IsStringClassId(receiver_cid)) {
+        type = Type::StringType();
+      } else if (receiver_cid == kDoubleCid) {
+        type = Type::Double();
+      } else if (RawObject::IsIntegerClassId(receiver_cid)) {
+        type = Type::IntType();
+      } else if (receiver_cid != kClosureCid) {
+        const Class& cls = Class::Handle(Z,
+            flow_graph->isolate()->class_table()->At(receiver_cid));
+        if (!cls.IsGeneric()) {
+          type = cls.CanonicalType();
+        }
+      }
+
+      if (!type.IsNull()) {
+          *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
+                                           call->GetBlock()->try_index());
+          (*entry)->InheritDeoptTarget(Z, call);
+          *last = new(Z) ConstantInstr(type);
+          flow_graph->AppendTo(*entry, *last,
+                               call->deopt_id() != Thread::kNoDeoptId ?

[Florian Schneider, 2016/10/06 18:03:19]

Can call ever have Thread::kNoDeoptId?

[Vyacheslav Egorov (Google), 2016/10/24 20:23:03]

That's an interesting question. In JIT it should not be possible. In AOT I
suspect that we can be much more liberal with deopt ids. 

 The code above does the same check so I will leave it for now and we will
investigate later.

+                               call->env() : NULL,
+                               FlowGraph::kValue);
+          return true;
+      }
+      return false;
+    }
+
     case MethodRecognizer::kOneByteStringSetAt: {
       // This is an internal method, no need to check argument types nor
       // range.
       *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                        call->GetBlock()->try_index());
       (*entry)->InheritDeoptTarget(Z, call);
       Definition* str = call->ArgumentAt(0);
       Definition* index = call->ArgumentAt(1);
       Definition* value = call->ArgumentAt(2);
       *last = new(Z) StoreIndexedInstr(
@@ skipping 13 matching lines @@
       return true;
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart