Inline recognized List factory in the flow graph optimizer.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 3662 matching lines @@
     // Check for core library get:_classId.
     intptr_t cid = Class::Handle(call->function().Owner()).id();
     // Currently only implemented for a subset of classes.
     ASSERT((cid == kOneByteStringCid) || (cid == kTwoByteStringCid) ||
            (cid == kExternalOneByteStringCid) ||
            (cid == kGrowableObjectArrayCid) ||
            (cid == kImmutableArrayCid) || (cid == kArrayCid));
     ConstantInstr* cid_instr = new ConstantInstr(Smi::Handle(Smi::New(cid)));
     ReplaceCall(call, cid_instr);
   }
+
+  if (call->function().IsFactory()) {
+    const Class& function_class = Class::Handle(call->function().Owner());
+    if ((function_class.library() == Library::CoreLibrary()) ||
+        (function_class.library() == Library::TypedDataLibrary())) {
+      intptr_t cid = FactoryRecognizer::ResultCid(call->function());
+      switch (cid) {
+        case kArrayCid: {
+          Value* type = new Value(call->ArgumentAt(0));
+          Value* num_elements = new Value(call->ArgumentAt(1));
+          if (num_elements->BindsToConstant() &&
+              num_elements->BoundConstant().IsSmi()) {
+            intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
+            if (length >= 0 && length <= Array::kMaxElements) {
+              CreateArrayInstr* create_array =
+                  new CreateArrayInstr(call->token_pos(), type, num_elements);
+              ReplaceCall(call, create_array);
+            }
+          }
+        }
+        default:
+          break;
+      }
+    }
+  }
 }
 
 
 void FlowGraphOptimizer::VisitStoreInstanceField(
     StoreInstanceFieldInstr* instr) {
   if (instr->IsUnboxedStore()) {
     ASSERT(instr->is_initialization_);
     // Determine if this field should be unboxed based on the usage of getter
     // and setter functions: The heuristic requires that the setter has a
     // usage count of at least 1/kGetterSetterRatio of the getter usage count.
@@ skipping 3419 matching lines @@
     SetValue(instr, Smi::ZoneHandle(Smi::New(object.GetClassId())));
     return;
   }
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitLoadField(LoadFieldInstr* instr) {
   if ((instr->recognized_kind() == MethodRecognizer::kObjectArrayLength) &&
       (instr->instance()->definition()->IsCreateArray())) {
-    const intptr_t length =
+    Value* num_elements =
         instr->instance()->definition()->AsCreateArray()->num_elements();
-    const Object& result = Smi::ZoneHandle(Smi::New(length));
-    SetValue(instr, result);
-    return;
+    if (num_elements->BindsToConstant() &&
+        num_elements->BoundConstant().IsSmi()) {
+      intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
+      const Object& result = Smi::ZoneHandle(Smi::New(length));
+      SetValue(instr, result);
+      return;
+    }
   }
 
   if (instr->IsImmutableLengthLoad()) {
     ConstantInstr* constant = instr->instance()->definition()->AsConstant();
     if (constant != NULL) {
       if (constant->value().IsString()) {
         SetValue(instr, Smi::ZoneHandle(
             Smi::New(String::Cast(constant->value()).Length())));
         return;
       }
@@ skipping 1306 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart