Revert "VM: Array bounds checks that don't deoptimize for precompiled code."

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
@@ skipping 2029 matching lines @@
 // Quick access to the current one.
 #undef Z
 #define Z (flow_graph->zone())
 
 static intptr_t PrepareInlineIndexedOp(FlowGraph* flow_graph,
                                        Instruction* call,
                                        intptr_t array_cid,
                                        Definition** array,
                                        Definition* index,
                                        Instruction** cursor) {
+  // Insert index smi check.
+  *cursor = flow_graph->AppendTo(
+      *cursor,
+      new(Z) CheckSmiInstr(new(Z) Value(index),
+                           call->deopt_id(),
+                           call->token_pos()),
+      call->env(),
+      FlowGraph::kEffect);
+
   // Insert array length load and bounds check.
   LoadFieldInstr* length =
       new(Z) LoadFieldInstr(
           new(Z) Value(*array),
           CheckArrayBoundInstr::LengthOffsetFor(array_cid),
           Type::ZoneHandle(Z, Type::SmiType()),
           call->token_pos());
   length->set_is_immutable(
       CheckArrayBoundInstr::IsFixedLengthArrayType(array_cid));
   length->set_result_cid(kSmiCid);
@@ skipping 444 matching lines @@
 
 
 static intptr_t PrepareInlineByteArrayBaseOp(
     FlowGraph* flow_graph,
     Instruction* call,
     intptr_t array_cid,
     intptr_t view_cid,
     Definition** array,
     Definition* byte_index,
     Instruction** cursor) {
+  // Insert byte_index smi check.
+  *cursor = flow_graph->AppendTo(*cursor,
+                                 new(Z) CheckSmiInstr(
+                                     new(Z) Value(byte_index),
+                                     call->deopt_id(),
+                                     call->token_pos()),
+                                 call->env(),
+                                 FlowGraph::kEffect);
+
   LoadFieldInstr* length =
       new(Z) LoadFieldInstr(
           new(Z) Value(*array),
           CheckArrayBoundInstr::LengthOffsetFor(array_cid),
           Type::ZoneHandle(Z, Type::SmiType()),
           call->token_pos());
   length->set_is_immutable(true);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(array_cid));
@@ skipping 280 matching lines @@
 
 
 // Returns the LoadIndexedInstr.
 static Definition* PrepareInlineStringIndexOp(
     FlowGraph* flow_graph,
     Instruction* call,
     intptr_t cid,
     Definition* str,
     Definition* index,
     Instruction* cursor) {
+
+  cursor = flow_graph->AppendTo(cursor,
+                                new(Z) CheckSmiInstr(
+                                    new(Z) Value(index),
+                                    call->deopt_id(),
+                                    call->token_pos()),
+                                call->env(),
+                                FlowGraph::kEffect);
+
   // Load the length of the string.
   // Treat length loads as mutable (i.e. affected by side effects) to avoid
   // hoisting them since we can't hoist the preceding class-check. This
   // is because of externalization of strings that affects their class-id.
   LoadFieldInstr* length = new(Z) LoadFieldInstr(
       new(Z) Value(str),
       String::length_offset(),
       Type::ZoneHandle(Z, Type::SmiType()),
       str->token_pos());
   length->set_result_cid(kSmiCid);
@@ skipping 403 matching lines @@
           call, entry, last);
     case MethodRecognizer::kSmi_bitAndFromSmi:
       return InlineSmiBitAndFromSmi(flow_graph, call, entry, last);
     default:
       return false;
   }
 }
 
 
 }  // namespace dart