Support Int32 representation for selected binary operations.

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/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 24 matching lines @@
     " otherwise use megamorphic dispatch.");
 DEFINE_FLAG(bool, remove_redundant_phis, true, "Remove redundant phis.");
 DEFINE_FLAG(bool, trace_constant_propagation, false,
     "Print constant propagation and useless code elimination.");
 DEFINE_FLAG(bool, trace_load_optimization, false,
     "Print live sets for load optimization pass.");
 DEFINE_FLAG(bool, trace_optimization, false, "Print optimization details.");
 DEFINE_FLAG(bool, truncating_left_shift, true,
     "Optimize left shift to truncate if possible");
 DEFINE_FLAG(bool, use_cha, true, "Use class hierarchy analysis.");
+#if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_IA32)
+DEFINE_FLAG(bool, trace_smi_widening, false, "Trace Smi->Int32 widening pass.");
+#endif
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, source_lines);
 DECLARE_FLAG(bool, trace_type_check_elimination);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 
 // Quick access to the locally defined isolate() method.
 #define I (isolate())
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
@@ skipping 519 matching lines @@
         ASSERT((replacement == NULL) || current->IsDefinition());
         ReplaceCurrentInstruction(&it, current, replacement, flow_graph_);
         changed = true;
       }
     }
   }
   return changed;
 }
 
 
+static bool IsUnboxedInteger(Representation rep) {
+  return (rep == kUnboxedInt32) ||
+         (rep == kUnboxedUint32) ||
+         (rep == kUnboxedMint);
+}
+
+
 void FlowGraphOptimizer::InsertConversion(Representation from,
                                           Representation to,
                                           Value* use,
                                           bool is_environment_use) {
   Instruction* insert_before;
   Instruction* deopt_target;
   PhiInstr* phi = use->instruction()->AsPhi();
   if (phi != NULL) {

[Florian Schneider, 2014/08/27 09:36:51]

Can you simplify the computation of deopt_target and check for int32-phis here?

e.g. 

if (phi != NULL && to != kUnboxedInt32) {
  insert_before = ...
  deopt_target = NULL;
} else {
  deopt_target = insert_before = ...
}

[Vyacheslav Egorov (Google), 2014/08/27 11:45:37]

Done.

     ASSERT(phi->is_alive());
     // For phis conversions have to be inserted in the predecessor.
     insert_before =
         phi->block()->PredecessorAt(use->use_index())->last_instruction();
     deopt_target = NULL;
   } else {
     deopt_target = insert_before = use->instruction();
   }
 
+  bool force_inherit_deopt_target = false;
+
   Definition* converted = NULL;
   if ((from == kTagged) && (to == kUnboxedMint)) {
     ASSERT((deopt_target != NULL) ||
            (use->Type()->ToCid() == kUnboxedMint));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     converted = new(I) UnboxIntegerInstr(use->CopyWithType(), deopt_id);
   } else if ((from == kUnboxedMint) && (to == kTagged)) {
     converted = new(I) BoxIntegerInstr(use->CopyWithType());
-  } else if ((from == kUnboxedMint) && (to == kUnboxedUint32)) {
-    converted = new(I) UnboxedIntConverterInstr(from, to, use->CopyWithType());
-  } else if ((from == kUnboxedUint32) && (to == kUnboxedMint)) {
-    converted = new(I) UnboxedIntConverterInstr(from, to, use->CopyWithType());
+  } else if (IsUnboxedInteger(from) && IsUnboxedInteger(to)) {
+    const intptr_t deopt_id = (to == kUnboxedInt32) && (deopt_target != NULL) ?
+        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+    force_inherit_deopt_target = (to == kUnboxedInt32) && (phi != NULL);
+    converted = new(I) UnboxedIntConverterInstr(from,
+                                                to,
+                                                use->CopyWithType(),
+                                                deopt_id);
+  } else if ((from == kUnboxedInt32) && (to == kUnboxedDouble)) {
+    converted = new Int32ToDoubleInstr(use->CopyWithType());
+  } else if ((from == kTagged) && (to == kUnboxedInt32)) {
+    const intptr_t deopt_id = (deopt_target != NULL) ?
+        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+    force_inherit_deopt_target = (phi != NULL);
+    converted = new UnboxInt32Instr(use->CopyWithType(), deopt_id);
+  } else if ((from == kUnboxedInt32) && (to == kTagged)) {
+    converted = new BoxInt32Instr(use->CopyWithType());
   } else if ((from == kTagged) && (to == kUnboxedUint32)) {
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     converted = new UnboxUint32Instr(use->CopyWithType(), deopt_id);
   } else if (from == kUnboxedMint && to == kUnboxedDouble) {
     ASSERT(CanUnboxDouble());
     // Convert by boxing/unboxing.
     // TODO(fschneider): Implement direct unboxed mint-to-double conversion.
     BoxIntegerInstr* boxed =
         new(I) BoxIntegerInstr(use->CopyWithType());
@@ skipping 60 matching lines @@
     if (from == kUnboxedDouble) {
       boxed = new(I) BoxDoubleInstr(use->CopyWithType());
     } else if (from == kUnboxedInt32x4) {
       boxed = new(I) BoxInt32x4Instr(use->CopyWithType());
     } else if (from == kUnboxedFloat32x4) {
       boxed = new(I) BoxFloat32x4Instr(use->CopyWithType());
     } else if (from == kUnboxedMint) {
       boxed = new(I) BoxIntegerInstr(use->CopyWithType());
     } else if (from == kUnboxedFloat64x2) {
       boxed = new(I) BoxFloat64x2Instr(use->CopyWithType());
+    } else if (from == kUnboxedInt32) {
+      boxed = new(I) BoxInt32Instr(use->CopyWithType());
+    } else if (from == kUnboxedUint32) {
+      boxed = new(I) BoxUint32Instr(use->CopyWithType());
     } else {
       UNIMPLEMENTED();
     }
     use->BindTo(boxed);
     InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
     Value* to_value = new(I) Value(boxed);
     if (to == kUnboxedDouble) {
       converted = new(I) UnboxDoubleInstr(to_value, deopt_id);
     } else if (to == kUnboxedInt32x4) {
       converted = new(I) UnboxInt32x4Instr(to_value, deopt_id);
     } else if (to == kUnboxedFloat32x4) {
       converted = new(I) UnboxFloat32x4Instr(to_value, deopt_id);
     } else if (to == kUnboxedMint) {
       converted = new(I) UnboxIntegerInstr(to_value, deopt_id);
     } else if (to == kUnboxedFloat64x2) {
       converted = new(I) UnboxFloat64x2Instr(to_value, deopt_id);
+    } else if (to == kUnboxedInt32) {
+      boxed = new(I) UnboxInt32Instr(use->CopyWithType(), deopt_id);
+    } else if (to == kUnboxedUint32) {
+      boxed = new(I) UnboxUint32Instr(use->CopyWithType(), deopt_id);
     } else {
       UNIMPLEMENTED();
     }
   }
   ASSERT(converted != NULL);
   InsertBefore(insert_before, converted, use->instruction()->env(),
                FlowGraph::kValue);
   if (is_environment_use) {
     use->BindToEnvironment(converted);
   } else {
     use->BindTo(converted);
   }
+
+  if (force_inherit_deopt_target) {
+    flow_graph_->CopyDeoptTarget(converted, insert_before);
+  }
 }
 
 
 void FlowGraphOptimizer::ConvertUse(Value* use, Representation from_rep) {
   const Representation to_rep =
       use->instruction()->RequiredInputRepresentation(use->use_index());
   if (from_rep == to_rep || to_rep == kNoRepresentation) {
     return;
   }
   InsertConversion(from_rep, to_rep, use, /*is_environment_use=*/ false);
@@ skipping 26 matching lines @@
     if (use->instruction()->MayThrow() &&
         use->instruction()->GetBlock()->InsideTryBlock()) {
       // Environment uses at calls inside try-blocks must be converted to
       // tagged representation.
       ConvertEnvironmentUse(it.Current(), from_rep);
     }
   }
 }
 
 
-// Returns true if phi's representation was changed.
-static bool UnboxPhi(PhiInstr* phi) {
-  Representation current = phi->representation();
-  Representation unboxed = current;
+static void UnboxPhi(PhiInstr* phi) {
+  Representation unboxed = phi->representation();
 
   switch (phi->Type()->ToCid()) {
     case kDoubleCid:
       if (CanUnboxDouble()) {
         unboxed = kUnboxedDouble;
       }
       break;
     case kFloat32x4Cid:
       if (ShouldInlineSimd()) {
         unboxed = kUnboxedFloat32x4;
       }
       break;
     case kInt32x4Cid:
       if (ShouldInlineSimd()) {
         unboxed = kUnboxedInt32x4;
       }
       break;
     case kFloat64x2Cid:
       if (ShouldInlineSimd()) {
         unboxed = kUnboxedFloat64x2;
       }
       break;
   }
 
-  if (unboxed != current) {
-    phi->set_representation(unboxed);
-    return true;
-  }
-
-  return false;
+  phi->set_representation(unboxed);
 }
 
 
 void FlowGraphOptimizer::SelectRepresentations() {
   // Conservatively unbox all phis that were proven to be of Double,
   // Float32x4, or Int32x4 type.
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     JoinEntryInstr* join_entry = block_order_[i]->AsJoinEntry();
     if (join_entry != NULL) {
       for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
@@ skipping 3774 matching lines @@
   }
 
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
+#if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_IA32)
+// Smi widening pass is only meaningful on platforms where Smi
+// is smaller than 32bit. For now only support it on ARM and ia32.
+
+class DefinitionWorklist {
+ public:
+  DefinitionWorklist(FlowGraph* flow_graph,
+                     intptr_t initial_capacity)
+      : defs_(initial_capacity),
+        contains_(new BitVector(flow_graph->current_ssa_temp_index())) {
+  }
+
+  void Add(Definition* defn) {
+    if (!Contains(defn)) {
+      defs_.Add(defn);
+      contains_->Add(defn->ssa_temp_index());
+    }
+  }
+
+  bool Contains(Definition* defn) const {
+    return (defn->ssa_temp_index() >= 0) &&
+        contains_->Contains(defn->ssa_temp_index());
+  }
+
+  const GrowableArray<Definition*>& definitions() const { return defs_; }
+  BitVector* contains() const { return contains_; }
+
+  void Clear() {
+    defs_.TruncateTo(0);
+    contains_->Clear();
+  }
+
+ private:
+  GrowableArray<Definition*> defs_;
+  BitVector* contains_;
+};
+
+
+static bool CanBeWidened(BinarySmiOpInstr* smi_op) {
+  return BinaryInt32OpInstr::IsSupported(smi_op->op_kind(),
+                                         smi_op->left(),
+                                         smi_op->right());
+}
+
+
+static bool BenefitsFromWidening(BinarySmiOpInstr* smi_op) {
+  switch (smi_op->op_kind()) {
+    case Token::kMUL:
+    case Token::kSHR:
+      // For kMUL we save untagging of the argument for kSHR
+      // we save tagging of the result.
+      return true;

[Florian Schneider, 2014/08/27 09:36:51]

For left and right shift we can save untagging of the shift count, if it is not
a compile-time constant.

[Vyacheslav Egorov (Google), 2014/08/27 11:45:37]

Done.

+    default:
+      return false;
+  }
+}
+
+
+void FlowGraphOptimizer::WidenSmiToInt32() {
+  GrowableArray<BinarySmiOpInstr*> candidates;
+
+  // Step 1. Collect all instructions that potentially benefit from widening of
+  // their operands (or their result) into int32 range.
+  for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
+       !block_it.Done();
+       block_it.Advance()) {
+    for (ForwardInstructionIterator instr_it(block_it.Current());
+         !instr_it.Done();
+         instr_it.Advance()) {
+      BinarySmiOpInstr* smi_op = instr_it.Current()->AsBinarySmiOp();
+      if (smi_op != NULL &&
+          BenefitsFromWidening(smi_op) &&
+          CanBeWidened(smi_op)) {
+        candidates.Add(smi_op);
+      }
+    }
+  }
+
+  if (candidates.length() == 0) {
+    return;
+  }
+
+  // Step 2. For each block in the graph compute which loop it belongs to.
+  // We will use this information later during computation of the widening's
+  // gain: we are going to assume that only conversion occuring inside the
+  // same loop should be counted against the gain, all other conversions
+  // can be hoisted and thus cost nothing compared to the loop cost itself.
+  const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
+    flow_graph()->loop_headers();
+
+  GrowableArray<intptr_t> loops(flow_graph_->preorder().length());
+  for (intptr_t i = 0; i < flow_graph_->preorder().length(); i++) {
+    loops.Add(-1);
+  }
+
+  for (intptr_t loop_id = 0; loop_id < loop_headers.length(); ++loop_id) {
+    for (BitVector::Iterator loop_it(loop_headers[loop_id]->loop_info());
+         !loop_it.Done();
+         loop_it.Advance()) {
+      loops[loop_it.Current()] = loop_id;
+    }
+  }
+
+  // Step 3. For each candidate transitively collect all other BinarySmiOpInstr
+  // and PhiInstr that depend on it and that it depends on and count amount of
+  // untagging opertaions that we save in assumption that this whole graph of
+  // values is using kUnboxedInt32 representaion instead of kTagged.

[Florian Schneider, 2014/08/27 09:36:51]

s/representaion/representation/

[Vyacheslav Egorov (Google), 2014/08/27 11:45:37]

Done.

+  // Convert those graphs that have positive gain to kUnboxedInt32.
+
+  // BitVector containing SSA indexes of all processed definitions. Used to skip
+  // those candidates that belong to dependency graph of another candidate.
+  BitVector* processed = new BitVector(flow_graph_->current_ssa_temp_index());
+
+  // Worklist used to collect dependency graph.
+  DefinitionWorklist worklist(flow_graph_, candidates.length());
+  for (intptr_t i = 0; i < candidates.length(); i++) {
+    BinarySmiOpInstr* op = candidates[i];
+    if (op->WasEliminated() || processed->Contains(op->ssa_temp_index())) {
+      continue;
+    }
+
+    if (FLAG_trace_smi_widening) {
+      OS::Print("analysing candidate: %s\n", op->ToCString());
+    }
+    worklist.Clear();
+    worklist.Add(op);
+
+    // Collect dependency graph. Note: more items are added to worklist
+    // inside this loop.
+    intptr_t gain = 0;
+    for (intptr_t j = 0; j < worklist.definitions().length(); j++) {
+      Definition* defn = worklist.definitions()[j];
+
+      if (FLAG_trace_smi_widening) {
+        OS::Print("> %s\n", defn->ToCString());
+      }
+
+      if (defn->IsBinarySmiOp() &&
+          BenefitsFromWidening(defn->AsBinarySmiOp())) {
+        gain++;
+        if (FLAG_trace_smi_widening) {
+          OS::Print("^ [%d] (o) %s\n", gain, defn->ToCString());
+        }
+      }
+
+      const intptr_t defn_loop = loops[defn->GetBlock()->preorder_number()];
+
+      // Process all inputs.
+      for (intptr_t k = 0; k < defn->InputCount(); k++) {
+        Definition* input = defn->InputAt(k)->definition();
+        if (input->IsBinarySmiOp() &&
+            CanBeWidened(input->AsBinarySmiOp())) {
+          worklist.Add(input);
+        } else if (input->IsPhi() && input->Type()->ToCid() == kSmiCid) {
+          worklist.Add(input);
+        } else if (input->IsBinaryMintOp()) {
+          // Mint operation produces untagged result. We avoid tagging.
+          gain++;
+          if (FLAG_trace_smi_widening) {
+            OS::Print("^ [%d] (i) %s\n", gain, input->ToCString());
+          }
+        } else if (defn_loop == loops[input->GetBlock()->preorder_number()] &&
+                   (input->Type()->ToCid() == kSmiCid)) {
+          // Input comes from the same loop, is known to be smi and requires
+          // untagging.
+          // TODO(vegorov) this heuristic assumes that values that are not
+          // known to be smi have to be checked and this check can be
+          // coalesced with untagging. Start coalescing them.
+          gain--;
+          if (FLAG_trace_smi_widening) {
+            OS::Print("v [%d] (i) %s\n", gain, input->ToCString());
+          }
+        }
+      }
+
+      // Process all uses.
+      for (Value* use = defn->input_use_list();
+           use != NULL;
+           use = use->next_use()) {
+        Instruction* instr = use->instruction();
+        Definition* use_defn = instr->AsDefinition();
+        if (use_defn == NULL) {
+          // We assume that tagging before returning or pushing argument costs
+          // very little compared to the cost of the return/call itself.
+          if (!instr->IsReturn() && !instr->IsPushArgument()) {
+            gain--;
+            if (FLAG_trace_smi_widening) {
+              OS::Print("v [%d] (u) %s\n",
+                        gain, use->instruction()->ToCString());
+            }
+          }
+          continue;
+        } else if (use_defn->IsBinarySmiOp() &&
+                   CanBeWidened(use_defn->AsBinarySmiOp())) {
+          worklist.Add(use_defn);
+        } else if (use_defn->IsPhi() &&
+                   use_defn->AsPhi()->Type()->ToCid() == kSmiCid) {
+          worklist.Add(use_defn);
+        } else if (use_defn->IsBinaryMintOp()) {
+          // BinaryMintOp requires untagging of its inputs.
+          // Converting kUnboxedInt32 to kUnboxedMint is essentially zero cost
+          // sign extension operation.
+          gain++;
+          if (FLAG_trace_smi_widening) {
+            OS::Print("^ [%d] (u) %s\n", gain, use->instruction()->ToCString());
+          }
+        } else if (defn_loop == loops[instr->GetBlock()->preorder_number()]) {
+          gain--;
+          if (FLAG_trace_smi_widening) {
+            OS::Print("v [%d] (u) %s\n", gain, use->instruction()->ToCString());
+          }
+        }
+      }
+    }
+
+    processed->AddAll(worklist.contains());
+
+    if (FLAG_trace_smi_widening) {
+      OS::Print("~ %s gain %d\n", op->ToCString(), gain);
+    }
+
+    if (gain > 0) {
+      // We have positive gain from widening. Convert all BinarySmiOpInstr into
+      // BinaryInt32OpInstr and set representation of all phis to kUnboxedInt32.
+      for (intptr_t j = 0; j < worklist.definitions().length(); j++) {
+        Definition* defn = worklist.definitions()[j];
+        ASSERT(defn->IsPhi() || defn->IsBinarySmiOp());
+
+        if (defn->IsBinarySmiOp()) {
+          BinarySmiOpInstr* smi_op = defn->AsBinarySmiOp();
+          BinaryInt32OpInstr* int32_op = new(I) BinaryInt32OpInstr(
+            smi_op->op_kind(),
+            smi_op->left()->CopyWithType(),
+            smi_op->right()->CopyWithType(),
+            smi_op->DeoptimizationTarget());
+
+          smi_op->ReplaceWith(int32_op, NULL);
+        } else if (defn->IsPhi()) {
+          defn->AsPhi()->set_representation(kUnboxedInt32);
+        }
+      }
+    }
+  }
+}
+#else
+void FlowGraphOptimizer::WidenSmiToInt32() {
+  // TODO(vegorov) ideally on 64-bit platforms we would like to narrow smi
+  // operations to 32-bit where it saves tagging and untagging and allows
+  // to use shorted (and faster) instructions. But we currently don't
+  // save enough range information in the ICData to drive this decision.
+}
+#endif
+
 void FlowGraphOptimizer::InferIntRanges() {
   RangeAnalysis range_analysis(flow_graph_);
   range_analysis.Analyze();
 }
 
 
 void TryCatchAnalyzer::Optimize(FlowGraph* flow_graph) {
   // For every catch-block: Iterate over all call instructions inside the
   // corresponding try-block and figure out for each environment value if it
   // is the same constant at all calls. If yes, replace the initial definition
@@ skipping 87 matching lines @@
   // speculatively hoisting checks.
   if (FLAG_trace_optimization) {
     OS::Print("Hoisting instruction %s:%" Pd " from B%" Pd " to B%" Pd "\n",
               current->DebugName(),
               current->GetDeoptId(),
               current->GetBlock()->block_id(),
               pre_header->block_id());
   }
   // Move the instruction out of the loop.
   current->RemoveEnvironment();
-  it->RemoveCurrentFromGraph();
+  if (it != NULL) {
+    it->RemoveCurrentFromGraph();
+  } else {
+    current->RemoveFromGraph();
+  }
   GotoInstr* last = pre_header->last_instruction()->AsGoto();
   // Using kind kEffect will not assign a fresh ssa temporary index.
   flow_graph()->InsertBefore(last, current, last->env(), FlowGraph::kEffect);
   current->deopt_id_ = last->GetDeoptId();
 }
 
 
-void LICM::TryHoistCheckSmiThroughPhi(ForwardInstructionIterator* it,
-                                      BlockEntryInstr* header,
-                                      BlockEntryInstr* pre_header,
-                                      CheckSmiInstr* current) {
-  PhiInstr* phi = current->value()->definition()->AsPhi();
-  if (!header->loop_info()->Contains(phi->block()->preorder_number())) {
+void LICM::TrySpecializeSmiPhi(PhiInstr* phi,
+                               BlockEntryInstr* header,
+                               BlockEntryInstr* pre_header) {
+  if (phi->Type()->ToCid() == kSmiCid) {
     return;
   }
 
-  if (phi->Type()->ToCid() == kSmiCid) {
-    it->RemoveCurrentFromGraph();
-    return;
-  }
-
   // Check if there is only a single kDynamicCid input to the phi that
   // comes from the pre-header.
   const intptr_t kNotFound = -1;
   intptr_t non_smi_input = kNotFound;
   for (intptr_t i = 0; i < phi->InputCount(); ++i) {
     Value* input = phi->InputAt(i);
     if (input->Type()->ToCid() != kSmiCid) {
       if ((non_smi_input != kNotFound) ||
           (input->Type()->ToCid() != kDynamicCid)) {
         // There are multiple kDynamicCid inputs or there is an input that is
         // known to be non-smi.
         return;
       } else {
         non_smi_input = i;
       }
     }
   }
 
   if ((non_smi_input == kNotFound) ||
       (phi->block()->PredecessorAt(non_smi_input) != pre_header)) {
     return;
   }
 
+  CheckSmiInstr* check = NULL;
+  for (Value* use = phi->input_use_list();
+       (use != NULL) && (check == NULL);
+       use = use->next_use()) {
+    check = use->instruction()->AsCheckSmi();
+  }
+
+  if (check == NULL) {
+    return;
+  }
+
   // Host CheckSmi instruction and make this phi smi one.
-  Hoist(it, pre_header, current);
+  Hoist(NULL, pre_header, check);
 
   // Replace value we are checking with phi's input.
-  current->value()->BindTo(phi->InputAt(non_smi_input)->definition());
+  check->value()->BindTo(phi->InputAt(non_smi_input)->definition());
 
   phi->UpdateType(CompileType::FromCid(kSmiCid));
 }
 
 
 // Load instructions handled by load elimination.
 static bool IsLoadEliminationCandidate(Instruction* instr) {
   return instr->IsLoadField()
       || instr->IsLoadIndexed()
       || instr->IsLoadStaticField()
       || instr->IsCurrentContext();
 }
 
 
 static bool IsLoopInvariantLoad(ZoneGrowableArray<BitVector*>* sets,
                                 intptr_t loop_header_index,
                                 Instruction* instr) {
   return IsLoadEliminationCandidate(instr) &&
       (sets != NULL) &&
       instr->HasPlaceId() &&
       ((*sets)[loop_header_index] != NULL) &&
       (*sets)[loop_header_index]->Contains(instr->place_id());
 }
 
 
+void LICM::OptimisticallySpecializeSmiPhis() {
+  if (!flow_graph()->parsed_function().function().
+          allows_hoisting_check_class()) {
+    // Do not hoist any.
+    return;
+  }
+
+  const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
+      flow_graph()->loop_headers();
+
+  for (intptr_t i = 0; i < loop_headers.length(); ++i) {
+    JoinEntryInstr* header = loop_headers[i]->AsJoinEntry();
+    // Skip loop that don't have a pre-header block.
+    BlockEntryInstr* pre_header = FindPreHeader(header);
+    if (pre_header == NULL) continue;
+
+    for (PhiIterator it(header); !it.Done(); it.Advance()) {
+      TrySpecializeSmiPhi(it.Current(), header, pre_header);
+    }
+  }
+}
+
+
 void LICM::Optimize() {
   if (!flow_graph()->parsed_function().function().
           allows_hoisting_check_class()) {
     // Do not hoist any.
     return;
   }
 
   const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
       flow_graph()->loop_headers();
 
@@ skipping 26 matching lines @@
               inputs_loop_invariant = false;
               break;
             }
           }
           if (inputs_loop_invariant &&
               !current->IsAssertAssignable() &&
               !current->IsAssertBoolean()) {
             // TODO(fschneider): Enable hoisting of Assert-instructions
             // if it safe to do.
             Hoist(&it, pre_header, current);
-          } else if (current->IsCheckSmi() &&
-                     current->InputAt(0)->definition()->IsPhi()) {
-            TryHoistCheckSmiThroughPhi(
-                &it, header, pre_header, current->AsCheckSmi());
           }
         }
       }
     }
   }
 }
 
 
 // Place describes an abstract location (e.g. field) that IR can load
 // from or store to.
@@ skipping 3092 matching lines @@
   ASSERT(!result.IsNull());
   SetValue(defn, result);
 }
 
 
 void ConstantPropagator::VisitBinarySmiOp(BinarySmiOpInstr* instr) {
   HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
 }
 
 
+void ConstantPropagator::VisitBinaryInt32Op(BinaryInt32OpInstr* instr) {
+  HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
+}
+
+
 void ConstantPropagator::VisitBoxInteger(BoxIntegerInstr* instr) {
   // TODO(kmillikin): Handle box operation.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnboxInteger(UnboxIntegerInstr* instr) {
   // TODO(kmillikin): Handle unbox operation.
   SetValue(instr, non_constant_);
 }
@@ skipping 41 matching lines @@
   const Object& value = instr->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
     SetValue(instr, Double::Handle(I,
         Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
   } else if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
 
+void ConstantPropagator::VisitInt32ToDouble(Int32ToDoubleInstr* instr) {
+  const Object& value = instr->value()->definition()->constant_value();
+  if (IsConstant(value) && value.IsInteger()) {
+    SetValue(instr, Double::Handle(I,
+        Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
+  } else if (IsNonConstant(value)) {
+    SetValue(instr, non_constant_);
+  }
+}
+
+
 void ConstantPropagator::VisitDoubleToInteger(DoubleToIntegerInstr* instr) {
   // TODO(kmillikin): Handle conversion.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitDoubleToSmi(DoubleToSmiInstr* instr) {
   // TODO(kmillikin): Handle conversion.
   SetValue(instr, non_constant_);
 }
@@ skipping 364 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnboxUint32(UnboxUint32Instr* instr) {
   // TODO(kmillikin): Handle unbox operation.
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitBoxInt32(BoxInt32Instr* instr) {
+  // TODO(kmillikin): Handle box operation.
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitUnboxInt32(UnboxInt32Instr* instr) {
+  // TODO(kmillikin): Handle unbox operation.
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitUnboxedIntConverter(
     UnboxedIntConverterInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitBinaryUint32Op(BinaryUint32OpInstr* instr) {
   HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
   TruncateInteger(instr, static_cast<int64_t>(0xFFFFFFFF));
 }
@@ skipping 1220 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart