Add type propagation phase in optimizing compiler (work in progress).

runtime/vm/flow_graph_optimizer.cc

 // 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.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
+DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, trace_optimization);
+DECLARE_FLAG(bool, trace_type_check_elimination);
 
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
 static bool ICDataHasReceiverClassId(const ICData& ic_data, intptr_t class_id) {
   ASSERT(ic_data.num_args_tested() > 0);
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     const intptr_t test_class_id = ic_data.GetReceiverClassIdAt(i);
@@ skipping 331 matching lines @@
     return false;
   }
   ToDoubleComp* coerce = new ToDoubleComp(
       comp->ArgumentAt(0)->value(), from_kind, comp);
   instr->set_computation(coerce);
   RemovePushArguments(comp);
   return true;
 }
 
 
-
-
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallComp* comp,
                                            BindInstr* instr) {
   if (comp->HasICData() && (comp->ic_data()->NumberOfChecks() > 0)) {
     const Token::Kind op_kind = comp->token_kind();
     if (Token::IsBinaryToken(op_kind) &&
         TryReplaceWithBinaryOp(instr, comp, op_kind)) {
       return;
     }
     if (Token::IsUnaryToken(op_kind) &&
         TryReplaceWithUnaryOp(instr, comp, op_kind)) {
@@ skipping 56 matching lines @@
       field,
       comp->InputAt(0),
       comp->InputAt(1),
       comp);
   store->set_ic_data(comp->ic_data());
   instr->set_computation(store);
   return true;
 }
 
 
-
 void FlowGraphOptimizer::VisitInstanceSetter(InstanceSetterComp* comp,
                                              BindInstr* instr) {
   // TODO(srdjan): Add assignable check node if --enable_type_checks.
   if (comp->HasICData() && !FLAG_enable_type_checks) {
     if (TryInlineInstanceSetter(instr, comp)) {
       return;
     }
   }
   // TODO(srdjan): Polymorphic dispatch to setters or deoptimize.
 }
@@ skipping 82 matching lines @@
     }
   }
 }
 
 
 void FlowGraphOptimizer::VisitBind(BindInstr* instr) {
   instr->computation()->Accept(this, instr);
 }
 
 
+void FlowGraphTypePropagator::VisitAssertAssignable(AssertAssignableComp* comp,
+                                                    BindInstr* instr) {
+  if (FLAG_eliminate_type_checks &&
+      (comp->value() != NULL) &&
+      !comp->dst_type().IsMalformed() &&
+      comp->value()->StaticTypeIsMoreSpecificThan(comp->dst_type())) {
+    // TODO(regis): Eliminate type check by removing comp node from graph.
+    if (FLAG_trace_type_check_elimination) {
+      FlowGraphPrinter::PrintTypeCheck(parsed_function(),
+                                       comp->token_pos(),
+                                       comp->value(),
+                                       comp->dst_type(),
+                                       comp->dst_name(),
+                                       /*eliminated*/ true);
+    }
+  }
+}
+
+
+void FlowGraphTypePropagator::VisitBind(BindInstr* instr) {
+  instr->computation()->Accept(this, instr);
+}
+
 
 void FlowGraphAnalyzer::Analyze() {
   is_leaf_ = true;
   for (intptr_t i = 0; i < blocks_.length(); ++i) {
     BlockEntryInstr* entry = blocks_[i];
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       LocationSummary* locs = it.Current()->locs();
       if ((locs != NULL) && locs->is_call()) {
         is_leaf_ = false;
         return;
       }
     }
   }
 }
 
+
+void FlowGraphTypePropagator::PropagateTypes() {
+  VisitBlocks();
+}
+
 }  // namespace dart