Propagate class ids using existing type propagation framework.

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"
 #include "vm/parser.h"
@@ skipping 731 matching lines @@
     for (intptr_t i = 0; i < join_entry->phis()->length(); ++i) {
       PhiInstr* phi = (*join_entry->phis())[i];
       if (phi != NULL) {
         VisitPhi(phi);
       }
     }
   }
 }
 
 
+// TODO(srdjan): Investigate if the propagated cid should be more specific.
+void FlowGraphTypePropagator::VisitPushArgument(PushArgumentInstr* push) {
+  if (!push->has_propagated_cid()) push->SetPropagatedCid(kDynamicCid);
+}
+
+
 void FlowGraphTypePropagator::VisitBind(BindInstr* bind) {
   // No need to propagate the input types of the bound computation, as long as
   // PhiInstr's are handled as part of JoinEntryInstr.
   // Visit computation and possibly eliminate type check.
   bind->computation()->Accept(this, bind);
   // The current bind may have been removed from the graph.
   if (current_iterator()->Current() == bind) {
     // Current bind was not removed.
     // Cache propagated computation type.
     AbstractType& computation_type =
         AbstractType::Handle(bind->computation()->CompileType());
     bool changed = bind->SetPropagatedType(computation_type);
     if (changed) {
       still_changing_ = true;
     }
+    // Propagate class ids.
+    intptr_t cid = bind->computation()->ResultCid();
+    changed = bind->SetPropagatedCid(cid);
+    if (changed) {
+      still_changing_ = true;
+    }
   }
 }
 
 
 void FlowGraphTypePropagator::VisitPhi(PhiInstr* phi) {
   // We could set the propagated type of the phi to the least upper bound of its
   // input propagated types. However, keeping all propagated types allows us to
   // optimize method dispatch.
   // TODO(regis): Support a set of propagated types. For now, we compute the
   // least specific of the input propagated types.
   AbstractType& type = AbstractType::Handle(phi->LeastSpecificInputType());
   bool changed = phi->SetPropagatedType(type);
   if (changed) {
     still_changing_ = true;
   }
+
+  // Merge class ids: if any two inputs have different class ids then result
+  // is kDynamicCid.
+  intptr_t merged_cid = kIllegalCid;
+  for (intptr_t i = 0; i < phi->InputCount(); i++) {
+    // Result cid of UseVal can be kIllegalCid if the referred definition
+    // has not been visited yet.
+    intptr_t cid = phi->InputAt(i)->ResultCid();
+    if (cid == kIllegalCid) {
+      still_changing_ = true;
+      continue;
+    }
+    if (merged_cid == kIllegalCid) {
+      // First time set.
+      merged_cid = cid;
+    } else if (merged_cid != cid) {
+      merged_cid = kDynamicCid;
+    }
+  }
+  if (merged_cid == kIllegalCid) {
+    merged_cid = kDynamicCid;
+  }
+  changed = phi->SetPropagatedCid(merged_cid);
+  if (changed) {
+    still_changing_ = true;
+  }
 }
 
 
 void FlowGraphTypePropagator::VisitParameter(ParameterInstr* param) {
   // TODO(regis): Once we inline functions, the propagated type of the formal
   // parameter will reflect the compile type of the passed-in argument.
   // For now, we do not know anything about the argument type and therefore set
   // it to the DynamicType, unless the argument is a compiler generated value,
   // i.e. the receiver argument or the constructor phase argument.
   AbstractType& param_type = AbstractType::Handle(Type::DynamicType());
   if (param->index() < 2) {
     const Function& function = parsed_function().function();
     if (((param->index() == 0) && function.IsDynamicFunction()) ||
         ((param->index() == 1) && function.IsConstructor())) {
       // Parameter is the receiver or the constructor phase.
       LocalScope* scope = parsed_function().node_sequence()->scope();
       param_type = scope->VariableAt(param->index())->type().raw();
     }
   }
   bool changed = param->SetPropagatedType(param_type);
   if (changed) {
     still_changing_ = true;
   }
+  param->SetPropagatedCid(kDynamicCid);
 }
 
 
 void FlowGraphTypePropagator::PropagateTypes() {
   // TODO(regis): Is there a way to make this more efficient, e.g. by visiting
   // only blocks depending on blocks that have changed and not the whole graph.
   do {
     still_changing_ = false;
     VisitBlocks();
   } while (still_changing_);
 }
 
 
 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->can_call()) {
         is_leaf_ = false;
         return;
       }
     }
   }
 }
 
 }  // namespace dart