Cleanup throwing of the RangeError in the runtime to remove duplicated code.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 18157 matching lines @@
 
   // If there is any left over space fill it with either an Array object or
   // just a plain object (depending on the amount of left over space) so
   // that it can be traversed over successfully during garbage collection.
   Object::MakeUnusedSpaceTraversable(array, capacity_size, used_size);
 
   return array.raw();
 }
 
 
+void Array::CopyFrom(intptr_t dst_start,

[Ivan Posva, 2014/09/02 15:27:07]

As discussed offline we will need to keep this as a copy of elements in the
general case, so maybe move this back to where it came from.

For copies into a newly allocated array (e.g from sublist or toList) though we
could use a similar strategy, which might call memmove as a leaf function
straight from recognized/intrisified code. Different CL maybe?

[Vyacheslav Egorov (Google), 2014/09/02 16:02:53]

It is not completely clear how to implement this. I would like to avoid
intensifying this if possible. 

I see two approaches:

- could merge allocation of the Array and it's filling into a single native to
guarantee that the array instance is *new*. This is not exactly straightforward
because there are type arguments involved in the business, but I can make it
work by making this an instance method on the array that we are cloning;
- could recognize pattern in the optimizer (though currently it's a bit hard as
we don't have infrastructure for recognizing points where GC could have
occurred).

Also here is an interesting thing to consider:

final dst = new List(100000);
var pos = 0;
for (var src in lists) {
  dst.setRange(pos, pos + src.length, src);
  pos += src.length;
}

This CL, in its current form on the current VM, also improves this case - out of
the box.

+                     const Array& source,
+                     intptr_t src_start,
+                     intptr_t count) const {
+  if (count < 0) {
+    Exceptions::ThrowByType(Exceptions::kArgument, Object::empty_array());
+  }
+  if (count == 0) {
+    return;
+  }
+  if ((src_start < 0) || ((src_start + count) > source.Length())) {
+    Exceptions::ThrowRangeError(Smi::Handle(Smi::New(src_start)));
+  }
+  if ((dst_start < 0) || ((dst_start + count) > Length())) {
+    Exceptions::ThrowRangeError(Smi::Handle(Smi::New(dst_start)));
+  }
+
+  NoGCScope no_gc_scope;
+  memmove(ObjectAddr(dst_start),
+          source.ObjectAddr(src_start),
+          count * kWordSize);
+  // Instead of calling write-barrier for every single element be pessimistic:
+  // put this object into store buffer if it is in the old space and there is
+  // a possibility that it now contains pointers into new space.
+  if (raw()->IsOldObject() &&
+      !raw()->IsRemembered() &&
+      (source.raw()->IsNewObject() || source.raw()->IsRemembered())) {
+    raw()->SetRememberedBit();
+    Isolate::Current()->store_buffer()->AddObject(raw());
+  }
+}
+
+
 bool Array::CheckAndCanonicalizeFields(const char** error_str) const {
   Object& obj = Object::Handle();
   // Iterate over all elements, canonicalize numbers and strings, expect all
   // other instances to be canonical otherwise report error (return false).
   for (intptr_t i = 0; i < Length(); i++) {
     obj = At(i);
     if (obj.IsInstance() && !obj.IsSmi() && !obj.IsCanonical()) {
       if (obj.IsNumber() || obj.IsString()) {
         obj = Instance::Cast(obj).CheckAndCanonicalize(NULL);
         ASSERT(!obj.IsNull());
@@ skipping 1394 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart