Set kArrayCid as ResultCid for CreateArray instruction.

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 3780 matching lines @@
       SetValue(instr, non_constant_);
     }
   } else if (IsConstant(left) && IsConstant(right)) {
     bool result = (left.raw() == right.raw());
     if (instr->kind() == Token::kNE_STRICT) result = !result;
     SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
   }
 }
 
 
+static bool CompareIntegers(Token::Kind kind,
+                            const Integer& left,
+                            const Integer& right) {
+  const int result = Integer::Cast(left).CompareWith(right);

[Florian Schneider, 2012/12/19 15:07:27]

Redundant Integer::Cast

+  switch (kind) {
+    case Token::kEQ: return (result == 0);
+    case Token::kNE: return (result != 0);
+    case Token::kLT: return (result < 0);
+    case Token::kGT: return (result > 0);
+    case Token::kLTE: return (result <= 0);
+    case Token::kGTE: return (result >= 0);
+    default:
+      UNREACHABLE();
+      return false;
+  }
+}
+
+
 void ConstantPropagator::VisitEqualityCompare(EqualityCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
-    // TODO(kmillikin): Handle equality comparison of constants.
-    SetValue(instr, non_constant_);
+    if (left.IsInteger() && right.IsInteger()) {
+      const bool result = CompareIntegers(instr->kind(),
+                                          Integer::Cast(left),
+                                          Integer::Cast(right));
+      SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
+    } else {
+      SetValue(instr, non_constant_);
+    }
   }
 }
 
 
 void ConstantPropagator::VisitRelationalOp(RelationalOpInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
-    // TODO(kmillikin): Handle relational comparison of constants.
-    SetValue(instr, non_constant_);
+    if (left.IsInteger() && right.IsInteger()) {
+      const bool result = CompareIntegers(instr->kind(),
+                                          Integer::Cast(left),
+                                          Integer::Cast(right));
+      SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
+    } else {
+      SetValue(instr, non_constant_);
+    }
   }
 }
 
 
 void ConstantPropagator::VisitNativeCall(NativeCallInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitStringCharCodeAt(StringCharCodeAtInstr* instr) {
@@ skipping 70 matching lines @@
 }
 
 
 void ConstantPropagator::VisitAllocateObjectWithBoundsCheck(
     AllocateObjectWithBoundsCheckInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitLoadField(LoadFieldInstr* instr) {
-  SetValue(instr, non_constant_);
+  if ((instr->recognized_kind() == MethodRecognizer::kObjectArrayLength) &&
+      (instr->value()->definition()->IsCreateArray())) {
+    const intptr_t length =
+        instr->value()->definition()->AsCreateArray()->ArgumentCount();
+    const Object& result = Smi::ZoneHandle(Smi::New(length));
+    SetValue(instr, result);
+  } else {
+    SetValue(instr, non_constant_);
+  }
 }
 
 
 void ConstantPropagator::VisitStoreVMField(StoreVMFieldInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
 void ConstantPropagator::VisitInstantiateTypeArguments(
     InstantiateTypeArgumentsInstr* instr) {
@@ skipping 320 matching lines @@
     // Replace branches where one target is unreachable with jumps.
     BranchInstr* branch = block->last_instruction()->AsBranch();
     if (branch != NULL) {
       TargetEntryInstr* if_true = branch->true_successor();
       TargetEntryInstr* if_false = branch->false_successor();
       JoinEntryInstr* join = NULL;
       Instruction* next = NULL;
 
       if (!reachable_->Contains(if_true->preorder_number())) {
         ASSERT(reachable_->Contains(if_false->preorder_number()));
-        ASSERT(branch->comparison()->IsStrictCompare());
         ASSERT(if_false->parallel_move() == NULL);
         ASSERT(if_false->loop_info() == NULL);
         join = new JoinEntryInstr(if_false->block_id(),
                                   if_false->try_index(),
                                   if_false->loop_depth());
         next = if_false->next();
       } else if (!reachable_->Contains(if_false->preorder_number())) {
-        ASSERT(branch->comparison()->IsStrictCompare());
         ASSERT(if_true->parallel_move() == NULL);
         ASSERT(if_true->loop_info() == NULL);
         join = new JoinEntryInstr(if_true->block_id(),
                                   if_true->try_index(),
                                   if_true->loop_depth());
         next = if_true->next();
       }
 
       if (join != NULL) {
         // Replace the branch with a jump to the reachable successor.
@@ skipping 26 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart