Cache the first evaluation of the compile time type of a definition as the

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 204 matching lines @@
   // here. In other words, if the compile type of the value is more specific
   // than the destination type, the run time type of the value, which is
   // guaranteed to be a subtype of the compile type, is also guaranteed to be
   // a subtype of the destination type and the type check can therefore be
   // eliminated.
   return compile_type.IsMoreSpecificThan(dst_type, NULL);
 }
 
 
 RawAbstractType* PhiInstr::CompileType() const {
-  if (HasPropagatedType()) {
-    return PropagatedType();
-  }
-  // If type propagation has not yet occured, we are reaching this phi via a
+  ASSERT(!HasPropagatedType());
+  // Since type propagation has not yet occured, we are reaching this phi via a
   // back edge phi input. Return null as compile type so that this input is
   // ignored in the first iteration of type propagation.
   return AbstractType::null();
 }
 
 
 RawAbstractType* PhiInstr::LeastSpecificInputType() const {
   AbstractType& least_specific_type = AbstractType::Handle();
   AbstractType& input_type = AbstractType::Handle();
   for (intptr_t i = 0; i < InputCount(); i++) {
@@ skipping 14 matching lines @@
       // The types are unrelated. No need to continue.
       least_specific_type = Type::ObjectType();
       break;
     }
   }
   return least_specific_type.raw();
 }
 
 
 RawAbstractType* ParameterInstr::CompileType() const {
-  // TODO(regis): Can type feedback provide information about the compile type
-  // of a passed-in parameter? In that case, it would be stored in the
-  // propagated_type_ field.
-  if (HasPropagatedType()) {
-    return PropagatedType();
-  }
+  ASSERT(!HasPropagatedType());
   // Note that returning the declared type of the formal parameter would be
   // incorrect, because ParameterInstr is used as input to the type check
   // verifying the run time type of the passed-in parameter and this check would
   // always be wrongly eliminated.
   return Type::DynamicType();
 }
 
 
 RawAbstractType* PushArgumentInstr::CompileType() const {
   return AbstractType::null();
@@ skipping 40 matching lines @@
   }
   current->definition_ = other;
 
   current->next_use_ = other->use_list();
   other->use_list()->previous_use_ = current;
   other->set_use_list(head);
 }
 
 
 RawAbstractType* BindInstr::CompileType() const {
-  if (HasPropagatedType()) {
-    return PropagatedType();
-  }
+  ASSERT(!HasPropagatedType());
   // The compile type may be requested when building the flow graph, i.e. before
   // type propagation has occurred.
   return computation()->CompileType();
 }
 
 
 void BindInstr::RecordAssignedVars(BitVector* assigned_vars,
                                    intptr_t fixed_parameter_count) {
   computation()->RecordAssignedVars(assigned_vars, fixed_parameter_count);
 }
@@ skipping 226 matching lines @@
   if (value().IsInstance()) {
     return Instance::Cast(value()).GetType();
   } else {
     ASSERT(value().IsAbstractTypeArguments());
     return AbstractType::null();
   }
 }
 
 
 RawAbstractType* UseVal::CompileType() const {
-  return definition()->CompileType();
+  if (definition()->HasPropagatedType()) {
+    return definition()->PropagatedType();
+  }
+  // The compile type may be requested when building the flow graph, i.e. before
+  // type propagation has occurred. To avoid repeatedly computing the compile
+  // type of the definition, we store it as initial propagated type.
+  AbstractType& type = AbstractType::Handle(definition()->CompileType());
+  definition()->SetPropagatedType(type);
+  return type.raw();
 }
 
 
 RawAbstractType* AssertAssignableComp::CompileType() const {
   const AbstractType& value_compile_type =
       AbstractType::Handle(value()->CompileType());
   if (!value_compile_type.IsNull() &&
       value_compile_type.IsMoreSpecificThan(dst_type(), NULL)) {
     return value_compile_type.raw();
   }
@@ skipping 705 matching lines @@
   if (compiler->is_ssa()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
 #undef __
 
 }  // namespace dart