Improve constant propagation to handle InstantiateTypeArguments.

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/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 3420 matching lines @@
 }
 
 
 void ConstantPropagator::VisitStoreVMField(StoreVMFieldInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
 void ConstantPropagator::VisitInstantiateTypeArguments(
     InstantiateTypeArgumentsInstr* instr) {
+  const Object& object =
+      instr->instantiator()->definition()->constant_value();
+  if (IsNonConstant(object)) {

[Kevin Millikin (Google), 2012/11/28 07:57:25]

If the value is unknown (bottom) it should not move up the lattice to
non-constant (top) because it prevents us discovering it is constant later.

I don't personally like the early return in such a small function, either.  In
my opinion, this is clearer:

if (IsNonConstant(object)) {
  SetValue(instr, non_constant_);
} else if (IsConstant(object)) {
  if (!object.IsNull() &&
      object.IsTypeArguments() &&
      TypeArguments::Cast(object).Length() == instr->type_arguments().Length()))
{
    SetValue(instr, object);
  } else {
    SetValue(instr, non_constant_);
  }
}

[Florian Schneider, 2012/11/28 13:02:59]

Thanks. Done.

+    SetValue(instr, non_constant_);
+    return;
+  }
+  if (!object.IsNull() && object.IsTypeArguments()) {

[srdjan, 2012/11/30 00:49:54]

You need to handle also the case for null otherwise "new List()" is not
optimized. (check generated code for "new List()" vs "new List<int>()").

[Florian Schneider, 2012/12/04 11:40:09]

Yes, that's a good suggestion. I'll add that case.

+    const TypeArguments& instantiator = TypeArguments::Cast(object);
+    if (instantiator.Length() == instr->type_arguments().Length()) {
+      SetValue(instr, instantiator);
+      return;
+    }
+  }
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitExtractConstructorTypeArguments(
     ExtractConstructorTypeArgumentsInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
@@ skipping 255 matching lines @@
 
     for (ForwardInstructionIterator i(block); !i.Done(); i.Advance()) {
       Definition* defn = i.Current()->AsDefinition();
       // Replace constant-valued instructions without observable side
       // effects.  Do this for smis only to avoid having to copy other
       // objects into the heap's old generation.
       //
       // TODO(kmillikin): Extend this to handle booleans, other number
       // types, etc.
       if ((defn != NULL) &&
-          defn->constant_value().IsSmi() &&
+          (defn->constant_value().IsSmi() ||
+           defn->constant_value().IsTypeArguments()) &&
           !defn->IsConstant() &&
           !defn->IsPushArgument() &&
           !defn->IsStoreIndexed() &&
           !defn->IsStoreInstanceField() &&
           !defn->IsStoreStaticField() &&
           !defn->IsStoreVMField()) {
         if (FLAG_trace_constant_propagation) {
           OS::Print("Constant v%"Pd" = %s\n",
                     defn->ssa_temp_index(),
                     defn->constant_value().ToCString());
@@ skipping 60 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart