Constant propagation in LoadIndexed when inputs are array/string and index constants.

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 6612 matching lines @@
 }
 
 
 void ConstantPropagator::VisitStringInterpolate(StringInterpolateInstr* instr) {
   SetValue(instr, non_constant_);
   return;
 }
 
 
 void ConstantPropagator::VisitLoadIndexed(LoadIndexedInstr* instr) {
-  SetValue(instr, non_constant_);
+  const Object& array_obj = instr->array()->definition()->constant_value();
+  const Object& index_obj = instr->index()->definition()->constant_value();
+  if (IsNonConstant(array_obj) || IsNonConstant(index_obj)) {
+    SetValue(instr, non_constant_);
+  } else if (IsConstant(array_obj) && IsConstant(index_obj)) {
+    // Need index to be Smi and array to be either String or an immutable array.
+    if (!index_obj.IsSmi()) {
+      // Should not occur.
+      SetValue(instr, non_constant_);
+      return;
+    }
+    const intptr_t index = Smi::Cast(index_obj).Value();
+    if (index >= 0) {
+      if (array_obj.IsString()) {
+        const String& str = String::Cast(array_obj);
+        if (str.Length() > index) {
+          SetValue(instr, Smi::Handle(Smi::New(str.CharAt(index))));
+          return;
+        }
+      } else if (array_obj.IsArray()) {
+        const Array& a = Array::Cast(array_obj);
+        if ((a.Length() > index) && a.IsImmutable()) {

[Cutch, 2013/12/18 05:21:19]

Is IsImmutable needed for a constant array?

[srdjan, 2013/12/18 16:40:01]

I believe it could be possible for constant propagator to have a constant that
is not a immutable array. Therefore it seems safer/more conservative this way. 

+          Instance& result = Instance::Handle();
+          result ^= a.At(index);
+          SetValue(instr, result);
+          return;
+        }
+      }
+    }
+    SetValue(instr, non_constant_);
+  }
 }
 
 
 void ConstantPropagator::VisitStoreIndexed(StoreIndexedInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
 void ConstantPropagator::VisitStoreInstanceField(
     StoreInstanceFieldInstr* instr) {
@@ skipping 1428 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