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

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 73 matching lines @@
 DEFINE_RUNTIME_ENTRY(TraceFunctionExit, 1) {
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   const String& function_name = String::Handle(function.name());
   const String& class_name =
       String::Handle(Class::Handle(function.Owner()).Name());
   OS::PrintErr("< Exiting '%s.%s'\n",
       class_name.ToCString(), function_name.ToCString());
 }
 
 
+DEFINE_RUNTIME_ENTRY(RangeError, 2) {
+  const Instance& length = Instance::CheckedHandle(arguments.ArgAt(0));
+  const Instance& index = Instance::CheckedHandle(arguments.ArgAt(1));
+  if (!length.IsInteger()) {
+    // Throw: new ArgumentError.value(length, "length", "is not an integer");
+    const Array& args = Array::Handle(Array::New(3));
+    args.SetAt(0, length);
+    args.SetAt(1, Symbols::Length());
+    args.SetAt(2, String::Handle(String::New("is not an integer")));
+    Exceptions::ThrowByType(Exceptions::kArgumentValue, args);
+  }
+  if (!index.IsInteger()) {
+    // Throw: new ArgumentError.value(index, "index", "is not an integer");
+    const Array& args = Array::Handle(Array::New(3));
+    args.SetAt(0, index);
+    args.SetAt(1, Symbols::Index());
+    args.SetAt(2, String::Handle(String::New("is not an integer")));
+    Exceptions::ThrowByType(Exceptions::kArgumentValue, args);
+  }
+  // Throw: new RangeError.range(index, 0, length, "length");
+  const Array& args = Array::Handle(Array::New(4));
+  args.SetAt(0, index);
+  args.SetAt(1, Integer::Handle(Integer::New(0)));
+  args.SetAt(2, length);
+  args.SetAt(3, Symbols::Length());
+  Exceptions::ThrowByType(Exceptions::kRange, args);
+}
+
+
 // Allocation of a fixed length array of given element type.
 // This runtime entry is never called for allocating a List of a generic type,
 // because a prior run time call instantiates the element type if necessary.
 // Arg0: array length.
 // Arg1: array type arguments, i.e. vector of 1 type, the element type.
 // Return value: newly allocated array of length arg0.
 DEFINE_RUNTIME_ENTRY(AllocateArray, 2) {
   const Instance& length = Instance::CheckedHandle(arguments.ArgAt(0));
   if (!length.IsInteger()) {
     // Throw: new ArgumentError.value(length, "length", "is not an integer");
@@ skipping 1826 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart