Improve array bounds check elimination for growable lists.

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 739 matching lines @@
                          CheckArrayBoundInstr::LengthOffsetFor(class_id),
                          Type::ZoneHandle(Type::SmiType()),
                          is_immutable);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(class_id));
   InsertBefore(call, length, NULL, Definition::kValue);
   InsertBefore(call,
                new CheckArrayBoundInstr(new Value(length),
                                         new Value(*index),
-                                        class_id,
                                         call),
                call->env(),
                Definition::kEffect);
 
   if (class_id == kGrowableObjectArrayCid) {
     // Insert data elements load.
     LoadFieldInstr* elements =
         new LoadFieldInstr(new Value(*array),
                            GrowableObjectArray::data_offset(),
                            Type::ZoneHandle(Type::DynamicType()));
@@ skipping 859 matching lines @@
     skip_check = constant_index.IsSmi() &&
         (Smi::Cast(constant_index).Value() < constant_string.Length());
   }
   if (!skip_check) {
     // Insert bounds check.
     LoadFieldInstr* length = BuildLoadStringLength(str);
     InsertBefore(call, length, NULL, Definition::kValue);
     InsertBefore(call,
                  new CheckArrayBoundInstr(new Value(length),
                                           new Value(index),
-                                          cid,
                                           call),
                  call->env(),
                  Definition::kEffect);
   }
   return new LoadIndexedInstr(new Value(str),
                               new Value(index),
                               FlowGraphCompiler::ElementSizeFor(cid),
                               cid,
                               Isolate::kNoDeoptId);  // Can't deoptimize.
 }
@@ skipping 578 matching lines @@
       new BinarySmiOpInstr(Token::kMUL,
                            call,
                            new Value(length),
                            new Value(bytes_per_element));
   InsertBefore(call, len_in_bytes, call->env(), Definition::kValue);
 
     // Check byte_index < len_in_bytes.
   InsertBefore(call,
                new CheckArrayBoundInstr(new Value(len_in_bytes),
                                         new Value(byte_index),
-                                        receiver_cid,
                                         call),
                call->env(),
                Definition::kEffect);
 
   // Insert load of elements for external typed arrays.
   if (RawObject::IsExternalTypedDataClassId(receiver_cid)) {
     LoadUntaggedInstr* elements =
         new LoadUntaggedInstr(new Value(*array),
                               ExternalTypedData::data_offset());
     InsertBefore(call, elements, NULL, Definition::kValue);
@@ skipping 864 matching lines @@
       ConstrainValueAfterCheckArrayBound(
           defn,
           use->instruction()->AsCheckArrayBound());
     }
   }
 }
 
 
 void RangeAnalysis::ConstrainValueAfterCheckArrayBound(
     Definition* defn, CheckArrayBoundInstr* check) {
-  if (!CheckArrayBoundInstr::IsFixedLengthArrayType(check->array_type())) {
-    return;
-  }
-
   Definition* length = check->length()->definition();
 
   Range* constraint_range = new Range(
       RangeBoundary::FromConstant(0),
       RangeBoundary::FromDefinition(length, -1));
   InsertConstraintFor(defn, constraint_range, check);
 }
 
 
 void RangeAnalysis::InsertConstraints() {
@@ skipping 3461 matching lines @@
 
   // Insert materializations at environment uses.
   const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, cls, *fields);
   }
 }
 
 
 }  // namespace dart