On Ia32 optimistically assume that results from int32 and uint32 array loads fit into Smi. Only if …

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 715 matching lines @@
                             needs_store_barrier, array_cid, call->deopt_id());
   call->ReplaceWith(array_op, current_iterator());
   RemovePushArguments(call);
   return true;
 }
 
 
 
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   const intptr_t class_id = ReceiverClassId(call);
+  // Set deopt_id to a valid id if the LoadIndexedInstr can cause deopt.
+  intptr_t deopt_id = Isolate::kNoDeoptId;
   switch (class_id) {
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
     case kFloat32ArrayCid:
     case kFloat64ArrayCid:
     case kInt8ArrayCid:
     case kUint8ArrayCid:
     case kUint8ClampedArrayCid:
     case kExternalUint8ArrayCid:
     case kInt16ArrayCid:
     case kUint16ArrayCid:
       break;
     case kInt32ArrayCid:
     case kUint32ArrayCid:
       // Check if elements fit into a smi or the platform supports unboxed
       // mints.
       if ((kSmiBits < 32) && !FlowGraphCompiler::SupportsUnboxedMints()) {
         return false;
       }
+      // Set deopt_id if we can optimistically assume that the result is Smi.
+      // TODO(srdjan): Add better signal if this instruction caused

[Florian Schneider, 2013/01/29 19:57:58]

call->ic_data().deopt_reason() should contain the last deopt reason-id. It can
be used to fall back to mint representation in the non-smi case.

+      // deoptimization. This solution: only if no deoptimization occured in
+      // this method is it guaranteed that this instruction did not cause
+      // deoptimization.
+      if (flow_graph_->parsed_function().function().deoptimization_counter()
+          > 0) {
+        deopt_id = Isolate::kNoDeoptId;
+      } else {
+        deopt_id = call->deopt_id();
+      }
       break;
     default:
       return false;
   }
   Value* array = NULL;
   Value* index = NULL;
   intptr_t array_cid = PrepareIndexedOp(call, class_id, &array, &index);
-  Definition* array_op = new LoadIndexedInstr(array, index, array_cid);
+  Definition* array_op =
+      new LoadIndexedInstr(array, index, array_cid, deopt_id);
   call->ReplaceWith(array_op, current_iterator());
   RemovePushArguments(call);
   return true;
 }
 
 
 void FlowGraphOptimizer::InsertBefore(Instruction* next,
                                       Instruction* instr,
                                       Environment* env,
                                       Definition::UseKind use_kind) {
@@ skipping 508 matching lines @@
   if (!skip_check) {
     // Insert bounds check.
     InsertBefore(call,
                  new CheckArrayBoundInstr(str->Copy(),
                                           index->Copy(),
                                           cid,
                                           call),
                  call->env(),
                  Definition::kEffect);
   }
-  return new LoadIndexedInstr(str, index, cid);
+  return new LoadIndexedInstr(str, index, cid, Isolate::kNoDeoptId);
 }
 
 
 void FlowGraphOptimizer::ReplaceWithMathCFunction(
   InstanceCallInstr* call,
   MethodRecognizer::Kind recognized_kind) {
   AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
   ZoneGrowableArray<Value*>* args =
       new ZoneGrowableArray<Value*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
@@ skipping 3294 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart