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 643 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* bind) {
+  if (!bind->has_propagated_cid()) bind->SetPropagatedCid(kDynamicCid);

[regis, 2012/08/16 01:07:44]

I do not understand why you have to do this.
Is the bind outside of the instruction stream?

[srdjan, 2012/08/16 01:21:28]

s/bind/push/
PushArgumentInstr is in the instructions stream, but we do not do anything with
it yet. We may want to in the future.

+}
+
+
 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);
   // Cache propagated computation type.
   AbstractType& type = AbstractType::Handle(bind->computation()->CompileType());
   bool changed = bind->SetPropagatedType(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) {

[regis, 2012/08/16 01:07:44]

I do not think this can happen. This would mean that all inputs are on back
edges.

[srdjan, 2012/08/16 01:21:28]

I think it is theoretically possible to order the graph in such a way that all
back edges are after the phi.

+    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());
@@ skipping 31 matching lines @@
       LocationSummary* locs = it.Current()->locs();
       if ((locs != NULL) && locs->can_call()) {
         is_leaf_ = false;
         return;
       }
     }
   }
 }
 
 }  // namespace dart