Support scalar lists in array bounds check elimination.

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 1850 matching lines @@
   // rename all uses that are dominated by it.
   ConstraintInstr* InsertConstraintFor(Definition* defn,
                                        Range* constraint,
                                        Instruction* after);
 
   void ConstrainValueAfterBranch(Definition* defn, Value* use);
   void ConstrainValueAfterCheckArrayBound(Definition* defn,
                                           CheckArrayBoundInstr* check);
   Definition* LoadArrayLength(CheckArrayBoundInstr* check);
 
-
-
   // Replace uses of the definition def that are dominated by instruction dom
   // with uses of other definition.
   void RenameDominatedUses(Definition* def,
                            Instruction* dom,
                            Definition* other);
 
 
   // Walk the dominator tree and infer ranges for smi values.
   void InferRanges();
   void InferRangesRecursive(BlockEntryInstr* block);
@@ skipping 336 matching lines @@
       (allocation->ResultCid() == kArrayCid)) {
     // For fixed length arrays check if array is the result of a constructor
     // call. In this case we can use the length passed to the constructor
     // instead of loading it from array itself.
     length = allocation->ArgumentAt(1)->value()->definition();
   } else {
     // Load length from the array. Do not insert instruction into the graph.
     // It will only be used in range boundaries.
     LoadFieldInstr* length_load = new LoadFieldInstr(
         check->array()->Copy(),
-        Array::length_offset(),
+        CheckArrayBoundInstr::LengthOffsetFor(check->array_type()),
         Type::ZoneHandle(Type::SmiType()),
         true);  // Immutable.
     length_load->set_recognized_kind(MethodRecognizer::kObjectArrayLength);
     length_load->set_result_cid(kSmiCid);
     length_load->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
     length = length_load;
   }
 
   ASSERT(length != NULL);
   array_lengths_.Insert(ArrayLengthData(array, length));
   return length;
 }
 
 
 void RangeAnalysis::ConstrainValueAfterCheckArrayBound(
     Definition* defn, CheckArrayBoundInstr* check) {
-  if ((check->array_type() != kArrayCid) &&
-      (check->array_type() != kImmutableArrayCid)) {
+  if (!CheckArrayBoundInstr::IsFixedLengthArrayType(check->array_type())) {
     return;
   }
 
   Definition* length = LoadArrayLength(check);
 
   Range* constraint_range = new Range(
       RangeBoundary::FromConstant(0),
       RangeBoundary::FromDefinition(length, -1));
   InsertConstraintFor(defn, constraint_range, check);
 }
@@ skipping 2165 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart