Add new FrameArray type

src/objects.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 10159 matching lines @@
   array->SetLength(length + 2);
   return array;
 }
 
 
 bool ArrayList::IsFull() {
   int capacity = length();
   return kFirstIndex + Length() == capacity;
 }
 
+namespace {
 
-Handle<ArrayList> ArrayList::EnsureSpace(Handle<ArrayList> array, int length) {
+Handle<FixedArray> EnsureSpaceInFixedArray(Handle<FixedArray> array,
+                                           int length) {
   int capacity = array->length();
-  bool empty = (capacity == 0);
-  if (capacity < kFirstIndex + length) {
+  if (capacity < length) {
     Isolate* isolate = array->GetIsolate();
-    int new_capacity = kFirstIndex + length;
+    int new_capacity = length;
     new_capacity = new_capacity + Max(new_capacity / 2, 2);
     int grow_by = new_capacity - capacity;
     array = Handle<ArrayList>::cast(
         isolate->factory()->CopyFixedArrayAndGrow(array, grow_by));
-    if (empty) array->SetLength(0);
   }
   return array;
 }
 
+}  // namespace
+
+Handle<ArrayList> ArrayList::EnsureSpace(Handle<ArrayList> array, int length) {
+  const bool empty = (array->length() == 0);
+  auto ret = Handle<ArrayList>::cast(
+      EnsureSpaceInFixedArray(array, kFirstIndex + length));
+  if (empty) ret->SetLength(0);
+  return ret;
+}
+
+Handle<FrameArray> FrameArray::Allocate(Isolate* isolate,

[Toon Verwaest, 2016/08/23 13:14:08]

So I guess I'm suggesting that a FrameArray should be an ArrayList?

[jgruber, 2016/08/23 15:32:13]

Yes they're very similar. There doesn't seem to be good code reuse potential
though which is why I didn't subclass it.

+                                        int number_of_frames) {
+  DCHECK(0 <= number_of_frames);

[Toon Verwaest, 2016/08/23 13:14:08]

DCHECK_LE(0, number_of_frames);

[jgruber, 2016/08/23 15:32:13]

Done.

+  Factory* factory = isolate->factory();
+  Handle<FixedArray> result =
+      factory->NewFixedArrayWithHoles(LengthFor(number_of_frames));
+  return Handle<FrameArray>::cast(result);
+}
+
+Handle<FrameArray> FrameArray::AppendJSFrame(
+    Handle<FrameArray> in, int frame_ix, Handle<Object> receiver,
+    Handle<JSFunction> function, Handle<AbstractCode> code, int offset) {
+  Handle<FrameArray> array = EnsureSpace(in, LengthFor(frame_ix + 1));
+  array->SetReceiver(frame_ix, *receiver);
+  array->SetFunction(frame_ix, *function);
+  array->SetCode(frame_ix, *code);
+  array->SetOffset(frame_ix, Smi::FromInt(offset));
+  return array;
+}
+
+Handle<FrameArray> FrameArray::AppendWasmFrame(
+    Handle<FrameArray> in, int frame_ix, Handle<Object> wasm_object,
+    int wasm_function_index, Handle<AbstractCode> code, int offset) {
+  Handle<FrameArray> array = EnsureSpace(in, LengthFor(frame_ix + 1));
+  array->SetWasmObject(frame_ix, *wasm_object);
+  array->SetWasmFunctionIndex(frame_ix, Smi::FromInt(wasm_function_index));
+  array->SetCode(frame_ix, *code);
+  array->SetOffset(frame_ix, Smi::FromInt(offset));
+  return array;
+}
+
+Handle<FrameArray> FrameArray::EnsureSpace(Handle<FrameArray> array,
+                                           int length) {
+  return Handle<FrameArray>::cast(EnsureSpaceInFixedArray(array, length));
+}
+
 Handle<DescriptorArray> DescriptorArray::Allocate(Isolate* isolate,
                                                   int number_of_descriptors,
                                                   int slack,
                                                   PretenureFlag pretenure) {
   DCHECK(0 <= number_of_descriptors);
   Factory* factory = isolate->factory();
   // Do not use DescriptorArray::cast on incomplete object.
   int size = number_of_descriptors + slack;
   if (size == 0) return factory->empty_descriptor_array();
   // Allocate the array of keys.
@@ skipping 9070 matching lines @@
   for (PrototypeIterator iter(isolate, this, kStartAtReceiver,
                               PrototypeIterator::END_AT_NULL);
        !iter.IsAtEnd(); iter.AdvanceIgnoringProxies()) {
     if (iter.GetCurrent<Object>()->IsJSProxy()) return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8