Revision: 20581
Author: [email protected]
Date: Tue Apr 8 14:20:29 2014 UTC
Log: Further ElementsAccessor handlification (Get(),
AddElementsToFixedArray() and HasElement()).
[email protected], [email protected]
Review URL: https://codereview.chromium.org/227713003
http://code.google.com/p/v8/source/detail?r=20581
Modified:
/branches/bleeding_edge/src/elements.cc
/branches/bleeding_edge/src/elements.h
/branches/bleeding_edge/src/objects-inl.h
/branches/bleeding_edge/src/objects.cc
/branches/bleeding_edge/src/objects.h
=======================================
--- /branches/bleeding_edge/src/elements.cc Mon Apr 7 10:00:14 2014 UTC
+++ /branches/bleeding_edge/src/elements.cc Tue Apr 8 14:20:29 2014 UTC
@@ -311,7 +311,7 @@
UNIMPLEMENTED();
} else {
ASSERT(IsFastObjectElementsKind(to_kind));
- Handle<Object> value = from->get_as_handle(i + from_start);
+ Handle<Object> value = FixedDoubleArray::get(from, i + from_start);
to->set(i + to_start, *value, UPDATE_WRITE_BARRIER);
}
}
@@ -518,12 +518,13 @@
}
-void CheckArrayAbuse(JSObject* obj, const char* op, uint32_t key,
+void CheckArrayAbuse(Handle<JSObject> obj, const char* op, uint32_t key,
bool allow_appending) {
+ DisallowHeapAllocation no_allocation;
Object* raw_length = NULL;
const char* elements_type = "array";
if (obj->IsJSArray()) {
- JSArray* array = JSArray::cast(obj);
+ JSArray* array = JSArray::cast(*obj);
raw_length = array->length();
} else {
raw_length = Smi::FromInt(obj->elements()->length());
@@ -615,12 +616,12 @@
ElementsAccessorSubclass::ValidateImpl(*holder);
}
- static bool HasElementImpl(Object* receiver,
- JSObject* holder,
+ static bool HasElementImpl(Handle<Object> receiver,
+ Handle<JSObject> holder,
uint32_t key,
- FixedArrayBase* backing_store) {
+ Handle<FixedArrayBase> backing_store) {
return ElementsAccessorSubclass::GetAttributesImpl(
- receiver, holder, key, backing_store) != ABSENT;
+ *receiver, *holder, key, *backing_store) != ABSENT;
}
virtual bool HasElement(
@@ -628,9 +629,8 @@
Handle<JSObject> holder,
uint32_t key,
Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE {
- // TODO(ishell): Handlify HasElementImpl().
return ElementsAccessorSubclass::HasElementImpl(
- *receiver, *holder, key, *backing_store);
+ receiver, holder, key, backing_store);
}
// TODO(ishell): Temporary wrapper until handlified.
@@ -639,16 +639,6 @@
Handle<JSObject> holder,
uint32_t key,
Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE {
- CALL_HEAP_FUNCTION(holder->GetIsolate(),
- Get(*receiver, *holder, key, *backing_store),
- Object);
- }
-
- MUST_USE_RESULT virtual MaybeObject* Get(
- Object* receiver,
- JSObject* holder,
- uint32_t key,
- FixedArrayBase* backing_store) V8_FINAL V8_OVERRIDE {
if (!IsExternalArrayElementsKind(ElementsTraits::Kind) &&
FLAG_trace_js_array_abuse) {
CheckArrayAbuse(holder, "elements read", key);
@@ -663,13 +653,15 @@
receiver, holder, key, backing_store);
}
- MUST_USE_RESULT static MaybeObject* GetImpl(Object* receiver,
- JSObject* obj,
- uint32_t key,
- FixedArrayBase*
backing_store) {
- return (key < ElementsAccessorSubclass::GetCapacityImpl(backing_store))
- ? BackingStore::cast(backing_store)->get(key)
- : backing_store->GetHeap()->the_hole_value();
+ static Handle<Object> GetImpl(Handle<Object> receiver,
+ Handle<JSObject> obj,
+ uint32_t key,
+ Handle<FixedArrayBase> backing_store) {
+ if (key < ElementsAccessorSubclass::GetCapacityImpl(*backing_store)) {
+ return BackingStore::get(Handle<BackingStore>::cast(backing_store),
key);
+ } else {
+ return backing_store->GetIsolate()->factory()->the_hole_value();
+ }
}
MUST_USE_RESULT virtual PropertyAttributes GetAttributes(
@@ -832,20 +824,6 @@
Handle<JSObject> holder,
Handle<FixedArray> to,
Handle<FixedArrayBase> from) V8_FINAL V8_OVERRIDE {
- CALL_HEAP_FUNCTION(to->GetIsolate(),
- AddElementsToFixedArray(
- receiver.is_null() ? NULL : *receiver,
- holder.is_null() ? NULL : *holder,
- *to,
- *from),
- FixedArray);
- }
-
- static MUST_USE_RESULT MaybeObject* AddElementsToFixedArray(
- Object* receiver,
- JSObject* holder,
- FixedArray* to,
- FixedArrayBase* from) {
int len0 = to->length();
#ifdef ENABLE_SLOW_ASSERTS
if (FLAG_enable_slow_asserts) {
@@ -857,21 +835,20 @@
// Optimize if 'other' is empty.
// We cannot optimize if 'this' is empty, as other may have holes.
- uint32_t len1 = ElementsAccessorSubclass::GetCapacityImpl(from);
+ uint32_t len1 = ElementsAccessorSubclass::GetCapacityImpl(*from);
if (len1 == 0) return to;
// Compute how many elements are not in other.
uint32_t extra = 0;
for (uint32_t y = 0; y < len1; y++) {
- uint32_t key = ElementsAccessorSubclass::GetKeyForIndexImpl(from, y);
+ uint32_t key = ElementsAccessorSubclass::GetKeyForIndexImpl(*from,
y);
if (ElementsAccessorSubclass::HasElementImpl(
receiver, holder, key, from)) {
- MaybeObject* maybe_value =
+ Handle<Object> value =
ElementsAccessorSubclass::GetImpl(receiver, holder, key, from);
- Object* value;
- if (!maybe_value->To(&value)) return maybe_value;
+
ASSERT(!value->IsTheHole());
- if (!HasKey(to, value)) {
+ if (!HasKey(*to, *value)) {
extra++;
}
}
@@ -880,9 +857,8 @@
if (extra == 0) return to;
// Allocate the result
- FixedArray* result;
- MaybeObject* maybe_obj = from->GetHeap()->AllocateFixedArray(len0 +
extra);
- if (!maybe_obj->To(&result)) return maybe_obj;
+ Isolate* isolate = from->GetIsolate();
+ Handle<FixedArray> result = isolate->factory()->NewFixedArray(len0 +
extra);
// Fill in the content
{
@@ -898,15 +874,13 @@
uint32_t index = 0;
for (uint32_t y = 0; y < len1; y++) {
uint32_t key =
- ElementsAccessorSubclass::GetKeyForIndexImpl(from, y);
+ ElementsAccessorSubclass::GetKeyForIndexImpl(*from, y);
if (ElementsAccessorSubclass::HasElementImpl(
receiver, holder, key, from)) {
- MaybeObject* maybe_value =
+ Handle<Object> value =
ElementsAccessorSubclass::GetImpl(receiver, holder, key, from);
- Object* value;
- if (!maybe_value->To(&value)) return maybe_value;
- if (!value->IsTheHole() && !HasKey(to, value)) {
- result->set(len0 + index, value);
+ if (!value->IsTheHole() && !HasKey(*to, *value)) {
+ result->set(len0 + index, *value);
index++;
}
}
@@ -1037,7 +1011,8 @@
backing_store->map() == heap->sloppy_arguments_elements_map();
if (is_sloppy_arguments_elements_map) {
backing_store = handle(
-
BackingStore::cast(Handle<FixedArray>::cast(backing_store)->get(1)));
+
BackingStore::cast(Handle<FixedArray>::cast(backing_store)->get(1)),
+ isolate);
}
uint32_t length = static_cast<uint32_t>(
obj->IsJSArray()
@@ -1086,14 +1061,14 @@
}
static bool HasElementImpl(
- Object* receiver,
- JSObject* holder,
+ Handle<Object> receiver,
+ Handle<JSObject> holder,
uint32_t key,
- FixedArrayBase* backing_store) {
+ Handle<FixedArrayBase> backing_store) {
if (key >= static_cast<uint32_t>(backing_store->length())) {
return false;
}
- return !BackingStore::cast(backing_store)->is_the_hole(key);
+ return !Handle<BackingStore>::cast(backing_store)->is_the_hole(key);
}
static void ValidateContents(JSObject* holder, int length) {
@@ -1373,14 +1348,15 @@
friend class ElementsAccessorBase<AccessorClass,
ElementsKindTraits<Kind> >;
- MUST_USE_RESULT static MaybeObject* GetImpl(Object* receiver,
- JSObject* obj,
- uint32_t key,
- FixedArrayBase*
backing_store) {
- return
- key < AccessorClass::GetCapacityImpl(backing_store)
- ? BackingStore::cast(backing_store)->get(key)
- : backing_store->GetHeap()->undefined_value();
+ static Handle<Object> GetImpl(Handle<Object> receiver,
+ Handle<JSObject> obj,
+ uint32_t key,
+ Handle<FixedArrayBase> backing_store) {
+ if (key < AccessorClass::GetCapacityImpl(*backing_store)) {
+ return BackingStore::get(Handle<BackingStore>::cast(backing_store),
key);
+ } else {
+ return backing_store->GetIsolate()->factory()->undefined_value();
+ }
}
MUST_USE_RESULT static PropertyAttributes GetAttributesImpl(
@@ -1420,12 +1396,12 @@
return obj->GetIsolate()->factory()->true_value();
}
- static bool HasElementImpl(Object* receiver,
- JSObject* holder,
+ static bool HasElementImpl(Handle<Object> receiver,
+ Handle<JSObject> holder,
uint32_t key,
- FixedArrayBase* backing_store) {
+ Handle<FixedArrayBase> backing_store) {
uint32_t capacity =
- AccessorClass::GetCapacityImpl(backing_store);
+ AccessorClass::GetCapacityImpl(*backing_store);
return key < capacity;
}
};
@@ -1604,26 +1580,26 @@
return DeleteCommon(obj, key, mode);
}
- MUST_USE_RESULT static MaybeObject* GetImpl(
- Object* receiver,
- JSObject* obj,
+ static Handle<Object> GetImpl(
+ Handle<Object> receiver,
+ Handle<JSObject> obj,
uint32_t key,
- FixedArrayBase* store) {
- SeededNumberDictionary* backing_store =
SeededNumberDictionary::cast(store);
+ Handle<FixedArrayBase> store) {
+ Handle<SeededNumberDictionary> backing_store =
+ Handle<SeededNumberDictionary>::cast(store);
+ Isolate* isolate = backing_store->GetIsolate();
int entry = backing_store->FindEntry(key);
if (entry != SeededNumberDictionary::kNotFound) {
- Object* element = backing_store->ValueAt(entry);
+ Handle<Object> element(backing_store->ValueAt(entry), isolate);
PropertyDetails details = backing_store->DetailsAt(entry);
if (details.type() == CALLBACKS) {
- return obj->GetElementWithCallback(receiver,
- element,
- key,
- obj);
+ return JSObject::GetElementWithCallback(
+ obj, receiver, element, key, obj);
} else {
return element;
}
}
- return obj->GetHeap()->the_hole_value();
+ return isolate->factory()->the_hole_value();
}
MUST_USE_RESULT static PropertyAttributes GetAttributesImpl(
@@ -1669,12 +1645,13 @@
return MaybeHandle<AccessorPair>();
}
- static bool HasElementImpl(Object* receiver,
- JSObject* holder,
+ static bool HasElementImpl(Handle<Object> receiver,
+ Handle<JSObject> holder,
uint32_t key,
- FixedArrayBase* backing_store) {
- return SeededNumberDictionary::cast(backing_store)->FindEntry(key) !=
- SeededNumberDictionary::kNotFound;
+ Handle<FixedArrayBase> store) {
+ Handle<SeededNumberDictionary> backing_store =
+ Handle<SeededNumberDictionary>::cast(store);
+ return backing_store->FindEntry(key) !=
SeededNumberDictionary::kNotFound;
}
// TODO(ishell): Handlify when all callers are handlified.
@@ -1700,31 +1677,34 @@
SloppyArgumentsElementsAccessor,
ElementsKindTraits<SLOPPY_ARGUMENTS_ELEMENTS> >;
- MUST_USE_RESULT static MaybeObject* GetImpl(Object* receiver,
- JSObject* obj,
- uint32_t key,
- FixedArrayBase* parameters) {
- FixedArray* parameter_map = FixedArray::cast(parameters);
- Object* probe = GetParameterMapArg(obj, parameter_map, key);
+ MUST_USE_RESULT static Handle<Object> GetImpl(
+ Handle<Object> receiver,
+ Handle<JSObject> obj,
+ uint32_t key,
+ Handle<FixedArrayBase> parameters) {
+ Isolate* isolate = obj->GetIsolate();
+ Handle<FixedArray> parameter_map =
Handle<FixedArray>::cast(parameters);
+ Handle<Object> probe = GetParameterMapArg(obj, parameter_map, key);
if (!probe->IsTheHole()) {
+ DisallowHeapAllocation no_gc;
Context* context = Context::cast(parameter_map->get(0));
- int context_index = Smi::cast(probe)->value();
+ int context_index = Handle<Smi>::cast(probe)->value();
ASSERT(!context->get(context_index)->IsTheHole());
- return context->get(context_index);
+ return handle(context->get(context_index), isolate);
} else {
// Object is not mapped, defer to the arguments.
- FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
- MaybeObject* maybe_result =
ElementsAccessor::ForArray(arguments)->Get(
+ Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)),
+ isolate);
+ Handle<Object> result = ElementsAccessor::ForArray(arguments)->Get(
receiver, obj, key, arguments);
- Object* result;
- if (!maybe_result->ToObject(&result)) return maybe_result;
// Elements of the arguments object in slow mode might be slow
aliases.
if (result->IsAliasedArgumentsEntry()) {
- AliasedArgumentsEntry* entry = AliasedArgumentsEntry::cast(result);
+ DisallowHeapAllocation no_gc;
+ AliasedArgumentsEntry* entry =
AliasedArgumentsEntry::cast(*result);
Context* context = Context::cast(parameter_map->get(0));
int context_index = entry->aliased_context_slot();
ASSERT(!context->get(context_index)->IsTheHole());
- return context->get(context_index);
+ return handle(context->get(context_index), isolate);
} else {
return result;
}
@@ -1841,17 +1821,17 @@
return index;
}
- static bool HasElementImpl(Object* receiver,
- JSObject* holder,
+ static bool HasElementImpl(Handle<Object> receiver,
+ Handle<JSObject> holder,
uint32_t key,
- FixedArrayBase* parameters) {
- FixedArray* parameter_map = FixedArray::cast(parameters);
- Object* probe = GetParameterMapArg(holder, parameter_map, key);
+ Handle<FixedArrayBase> parameters) {
+ Handle<FixedArray> parameter_map =
Handle<FixedArray>::cast(parameters);
+ Handle<Object> probe = GetParameterMapArg(holder, parameter_map, key);
if (!probe->IsTheHole()) {
return true;
} else {
- FixedArrayBase* arguments =
- FixedArrayBase::cast(FixedArray::cast(parameter_map)->get(1));
+ Handle<FixedArrayBase> arguments(FixedArrayBase::cast(
+ Handle<FixedArray>::cast(parameter_map)->get(1)));
ElementsAccessor* accessor = ElementsAccessor::ForArray(arguments);
return !accessor->Get(receiver, holder, key, arguments)->IsTheHole();
}
=======================================
--- /branches/bleeding_edge/src/elements.h Mon Apr 7 10:00:14 2014 UTC
+++ /branches/bleeding_edge/src/elements.h Tue Apr 8 14:20:29 2014 UTC
@@ -253,12 +253,6 @@
// TODO(ishell): Non-handlified versions, used only by accessors'
// implementations. To be removed once elements.cc is handlified.
- MUST_USE_RESULT virtual MaybeObject* Get(
- Object* receiver,
- JSObject* holder,
- uint32_t key,
- FixedArrayBase* backing_store) = 0;
-
MUST_USE_RESULT virtual PropertyAttributes GetAttributes(
Object* receiver,
JSObject* holder,
@@ -278,7 +272,7 @@
DISALLOW_COPY_AND_ASSIGN(ElementsAccessor);
};
-void CheckArrayAbuse(JSObject* obj, const char* op, uint32_t key,
+void CheckArrayAbuse(Handle<JSObject> obj, const char* op, uint32_t key,
bool allow_appending = false);
Handle<Object> ArrayConstructInitializeElements(Handle<JSArray> array,
=======================================
--- /branches/bleeding_edge/src/objects-inl.h Tue Apr 8 10:00:57 2014 UTC
+++ /branches/bleeding_edge/src/objects-inl.h Tue Apr 8 14:20:29 2014 UTC
@@ -2173,6 +2173,11 @@
SLOW_ASSERT(index >= 0 && index < this->length());
return READ_FIELD(this, kHeaderSize + index * kPointerSize);
}
+
+
+Handle<Object> FixedArray::get(Handle<FixedArray> array, int index) {
+ return handle(array->get(index), array->GetIsolate());
+}
bool FixedArray::is_the_hole(int index) {
@@ -2240,11 +2245,12 @@
}
-Handle<Object> FixedDoubleArray::get_as_handle(int index) {
- if (is_the_hole(index)) {
- return GetIsolate()->factory()->the_hole_value();
+Handle<Object> FixedDoubleArray::get(Handle<FixedDoubleArray> array,
+ int index) {
+ if (array->is_the_hole(index)) {
+ return array->GetIsolate()->factory()->the_hole_value();
} else {
- return GetIsolate()->factory()->NewNumber(get_scalar(index));
+ return
array->GetIsolate()->factory()->NewNumber(array->get_scalar(index));
}
}
@@ -3612,9 +3618,16 @@
}
-MaybeObject* ExternalUint8ClampedArray::get(int index) {
+Object* ExternalUint8ClampedArray::get(int index) {
return Smi::FromInt(static_cast<int>(get_scalar(index)));
}
+
+
+Handle<Object> ExternalUint8ClampedArray::get(
+ Handle<ExternalUint8ClampedArray> array,
+ int index) {
+ return handle(array->get(index), array->GetIsolate());
+}
void ExternalUint8ClampedArray::set(int index, uint8_t value) {
@@ -3643,9 +3656,15 @@
}
-MaybeObject* ExternalInt8Array::get(int index) {
+Object* ExternalInt8Array::get(int index) {
return Smi::FromInt(static_cast<int>(get_scalar(index)));
}
+
+
+Handle<Object> ExternalInt8Array::get(Handle<ExternalInt8Array> array,
+ int index) {
+ return handle(array->get(index), array->GetIsolate());
+}
void ExternalInt8Array::set(int index, int8_t value) {
@@ -3662,9 +3681,15 @@
}
-MaybeObject* ExternalUint8Array::get(int index) {
+Object* ExternalUint8Array::get(int index) {
return Smi::FromInt(static_cast<int>(get_scalar(index)));
}
+
+
+Handle<Object> ExternalUint8Array::get(Handle<ExternalUint8Array> array,
+ int index) {
+ return handle(array->get(index), array->GetIsolate());
+}
void ExternalUint8Array::set(int index, uint8_t value) {
@@ -3681,9 +3706,15 @@
}
-MaybeObject* ExternalInt16Array::get(int index) {
+Object* ExternalInt16Array::get(int index) {
return Smi::FromInt(static_cast<int>(get_scalar(index)));
}
+
+
+Handle<Object> ExternalInt16Array::get(Handle<ExternalInt16Array> array,
+ int index) {
+ return handle(array->get(index), array->GetIsolate());
+}
void ExternalInt16Array::set(int index, int16_t value) {
@@ -3700,9 +3731,15 @@
}
-MaybeObject* ExternalUint16Array::get(int index) {
+Object* ExternalUint16Array::get(int index) {
return Smi::FromInt(static_cast<int>(get_scalar(index)));
}
+
+
+Handle<Object> ExternalUint16Array::get(Handle<ExternalUint16Array> array,
+ int index) {
+ return handle(array->get(index), array->GetIsolate());
+}
void ExternalUint16Array::set(int index, uint16_t value) {
@@ -3720,7 +3757,14 @@
MaybeObject* ExternalInt32Array::get(int index) {
- return GetHeap()->NumberFromInt32(get_scalar(index));
+ return GetHeap()->NumberFromInt32(get_scalar(index));
+}
+
+
+Handle<Object> ExternalInt32Array::get(Handle<ExternalInt32Array> array,
+ int index) {
+ return array->GetIsolate()->factory()->
+ NewNumberFromInt(array->get_scalar(index));
}
@@ -3739,7 +3783,14 @@
MaybeObject* ExternalUint32Array::get(int index) {
- return GetHeap()->NumberFromUint32(get_scalar(index));
+ return GetHeap()->NumberFromUint32(get_scalar(index));
+}
+
+
+Handle<Object> ExternalUint32Array::get(Handle<ExternalUint32Array> array,
+ int index) {
+ return array->GetIsolate()->factory()->
+ NewNumberFromUint(array->get_scalar(index));
}
@@ -3758,7 +3809,13 @@
MaybeObject* ExternalFloat32Array::get(int index) {
- return GetHeap()->NumberFromDouble(get_scalar(index));
+ return GetHeap()->NumberFromDouble(get_scalar(index));
+}
+
+
+Handle<Object> ExternalFloat32Array::get(Handle<ExternalFloat32Array>
array,
+ int index) {
+ return
array->GetIsolate()->factory()->NewNumber(array->get_scalar(index));
}
@@ -3779,6 +3836,12 @@
MaybeObject* ExternalFloat64Array::get(int index) {
return GetHeap()->NumberFromDouble(get_scalar(index));
}
+
+
+Handle<Object> ExternalFloat64Array::get(Handle<ExternalFloat64Array>
array,
+ int index) {
+ return
array->GetIsolate()->factory()->NewNumber(array->get_scalar(index));
+}
void ExternalFloat64Array::set(int index, double value) {
@@ -3925,6 +3988,13 @@
MaybeObject* FixedTypedArray<Traits>::get(int index) {
return Traits::ToObject(GetHeap(), get_scalar(index));
}
+
+template <class Traits>
+Handle<Object> FixedTypedArray<Traits>::get(
+ Handle<FixedTypedArray<Traits> > array,
+ int index) {
+ return Traits::ToHandle(array->GetIsolate(), array->get_scalar(index));
+}
template <class Traits>
MaybeObject* FixedTypedArray<Traits>::SetValue(uint32_t index, Object*
value) {
@@ -3960,46 +4030,92 @@
MaybeObject* Uint8ArrayTraits::ToObject(Heap*, uint8_t scalar) {
return Smi::FromInt(scalar);
}
+
+
+Handle<Object> Uint8ArrayTraits::ToHandle(Isolate* isolate, uint8_t
scalar) {
+ return handle(Smi::FromInt(scalar), isolate);
+}
MaybeObject* Uint8ClampedArrayTraits::ToObject(Heap*, uint8_t scalar) {
return Smi::FromInt(scalar);
}
+
+
+Handle<Object> Uint8ClampedArrayTraits::ToHandle(Isolate* isolate,
+ uint8_t scalar) {
+ return handle(Smi::FromInt(scalar), isolate);
+}
MaybeObject* Int8ArrayTraits::ToObject(Heap*, int8_t scalar) {
return Smi::FromInt(scalar);
}
+
+
+Handle<Object> Int8ArrayTraits::ToHandle(Isolate* isolate, int8_t scalar) {
+ return handle(Smi::FromInt(scalar), isolate);
+}
MaybeObject* Uint16ArrayTraits::ToObject(Heap*, uint16_t scalar) {
return Smi::FromInt(scalar);
}
+
+
+Handle<Object> Uint16ArrayTraits::ToHandle(Isolate* isolate, uint16_t
scalar) {
+ return handle(Smi::FromInt(scalar), isolate);
+}
MaybeObject* Int16ArrayTraits::ToObject(Heap*, int16_t scalar) {
return Smi::FromInt(scalar);
}
+
+
+Handle<Object> Int16ArrayTraits::ToHandle(Isolate* isolate, int16_t
scalar) {
+ return handle(Smi::FromInt(scalar), isolate);
+}
MaybeObject* Uint32ArrayTraits::ToObject(Heap* heap, uint32_t scalar) {
return heap->NumberFromUint32(scalar);
}
+
+
+Handle<Object> Uint32ArrayTraits::ToHandle(Isolate* isolate, uint32_t
scalar) {
+ return isolate->factory()->NewNumberFromUint(scalar);
+}
MaybeObject* Int32ArrayTraits::ToObject(Heap* heap, int32_t scalar) {
return heap->NumberFromInt32(scalar);
}
+
+
+Handle<Object> Int32ArrayTraits::ToHandle(Isolate* isolate, int32_t
scalar) {
+ return isolate->factory()->NewNumberFromInt(scalar);
+}
MaybeObject* Float32ArrayTraits::ToObject(Heap* heap, float scalar) {
return heap->NumberFromDouble(scalar);
}
+
+
+Handle<Object> Float32ArrayTraits::ToHandle(Isolate* isolate, float
scalar) {
+ return isolate->factory()->NewNumber(scalar);
+}
MaybeObject* Float64ArrayTraits::ToObject(Heap* heap, double scalar) {
return heap->NumberFromDouble(scalar);
}
+
+
+Handle<Object> Float64ArrayTraits::ToHandle(Isolate* isolate, double
scalar) {
+ return isolate->factory()->NewNumber(scalar);
+}
int Map::visitor_id() {
=======================================
--- /branches/bleeding_edge/src/objects.cc Tue Apr 8 13:14:03 2014 UTC
+++ /branches/bleeding_edge/src/objects.cc Tue Apr 8 14:20:29 2014 UTC
@@ -11987,6 +11987,20 @@
check_prototype,
set_mode);
}
+
+
+// TODO(ishell): Temporary wrapper until handlified.
+Handle<Object> JSObject::GetElementWithCallback(
+ Handle<JSObject> object,
+ Handle<Object> receiver,
+ Handle<Object> structure,
+ uint32_t index,
+ Handle<Object> holder) {
+ CALL_HEAP_FUNCTION(object->GetIsolate(),
+ object->GetElementWithCallback(
+ *receiver, *structure, index, *holder),
+ Object);
+}
MaybeObject* JSObject::GetElementWithCallback(Object* receiver,
@@ -12673,12 +12687,12 @@
Isolate* isolate = object->GetIsolate();
if (FLAG_trace_external_array_abuse &&
IsExternalArrayElementsKind(object->GetElementsKind())) {
- CheckArrayAbuse(*object, "external elements write", index);
+ CheckArrayAbuse(object, "external elements write", index);
}
if (FLAG_trace_js_array_abuse &&
!IsExternalArrayElementsKind(object->GetElementsKind())) {
if (object->IsJSArray()) {
- CheckArrayAbuse(*object, "elements write", index, true);
+ CheckArrayAbuse(object, "elements write", index, true);
}
}
switch (object->GetElementsKind()) {
=======================================
--- /branches/bleeding_edge/src/objects.h Tue Apr 8 12:33:08 2014 UTC
+++ /branches/bleeding_edge/src/objects.h Tue Apr 8 14:20:29 2014 UTC
@@ -2797,6 +2797,13 @@
Handle<Name> name,
PropertyAttributes* attributes);
+ MUST_USE_RESULT static Handle<Object> GetElementWithCallback(
+ Handle<JSObject> object,
+ Handle<Object> receiver,
+ Handle<Object> structure,
+ uint32_t index,
+ Handle<Object> holder);
+
MUST_USE_RESULT MaybeObject* GetElementWithCallback(Object* receiver,
Object* structure,
uint32_t index,
@@ -3043,6 +3050,7 @@
public:
// Setter and getter for elements.
inline Object* get(int index);
+ static inline Handle<Object> get(Handle<FixedArray> array, int index);
// Setter that uses write barrier.
inline void set(int index, Object* value);
inline bool is_the_hole(int index);
@@ -3159,8 +3167,7 @@
inline double get_scalar(int index);
inline int64_t get_representation(int index);
MUST_USE_RESULT inline MaybeObject* get(int index);
- // TODO(ishell): Rename as get() once all usages handlified.
- inline Handle<Object> get_as_handle(int index);
+ static inline Handle<Object> get(Handle<FixedDoubleArray> array, int
index);
inline void set(int index, double value);
inline void set_the_hole(int index);
@@ -4908,7 +4915,9 @@
// Setter and getter.
inline uint8_t get_scalar(int index);
- MUST_USE_RESULT inline MaybeObject* get(int index);
+ MUST_USE_RESULT inline Object* get(int index);
+ static inline Handle<Object> get(Handle<ExternalUint8ClampedArray> array,
+ int index);
inline void set(int index, uint8_t value);
// This accessor applies the correct conversion from Smi, HeapNumber and
@@ -4935,7 +4944,8 @@
public:
// Setter and getter.
inline int8_t get_scalar(int index);
- MUST_USE_RESULT inline MaybeObject* get(int index);
+ MUST_USE_RESULT inline Object* get(int index);
+ static inline Handle<Object> get(Handle<ExternalInt8Array> array, int
index);
inline void set(int index, int8_t value);
static Handle<Object> SetValue(Handle<ExternalInt8Array> array,
@@ -4962,7 +4972,8 @@
public:
// Setter and getter.
inline uint8_t get_scalar(int index);
- MUST_USE_RESULT inline MaybeObject* get(int index);
+ MUST_USE_RESULT inline Object* get(int index);
+ static inline Handle<Object> get(Handle<ExternalUint8Array> array, int
index);
inline void set(int index, uint8_t value);
static Handle<Object> SetValue(Handle<ExternalUint8Array> array,
@@ -4989,7 +5000,8 @@
public:
// Setter and getter.
inline int16_t get_scalar(int index);
- MUST_USE_RESULT inline MaybeObject* get(int index);
+ MUST_USE_RESULT inline Object* get(int index);
+ static inline Handle<Object> get(Handle<ExternalInt16Array> array, int
index);
inline void set(int index, int16_t value);
static Handle<Object> SetValue(Handle<ExternalInt16Array> array,
@@ -5016,7 +5028,9 @@
public:
// Setter and getter.
inline uint16_t get_scalar(int index);
- MUST_USE_RESULT inline MaybeObject* get(int index);
+ MUST_USE_RESULT inline Object* get(int index);
+ static inline Handle<Object> get(Handle<ExternalUint16Array> array,
+ int index);
inline void set(int index, uint16_t value);
static Handle<Object> SetValue(Handle<ExternalUint16Array> array,
@@ -5044,6 +5058,7 @@
// Setter and getter.
inline int32_t get_scalar(int index);
MUST_USE_RESULT inline MaybeObject* get(int index);
+ static inline Handle<Object> get(Handle<ExternalInt32Array> array, int
index);
inline void set(int index, int32_t value);
static Handle<Object> SetValue(Handle<ExternalInt32Array> array,
@@ -5071,6 +5086,8 @@
// Setter and getter.
inline uint32_t get_scalar(int index);
MUST_USE_RESULT inline MaybeObject* get(int index);
+ static inline Handle<Object> get(Handle<ExternalUint32Array> array,
+ int index);
inline void set(int index, uint32_t value);
static Handle<Object> SetValue(Handle<ExternalUint32Array> array,
@@ -5098,6 +5115,8 @@
// Setter and getter.
inline float get_scalar(int index);
MUST_USE_RESULT inline MaybeObject* get(int index);
+ static inline Handle<Object> get(Handle<ExternalFloat32Array> array,
+ int index);
inline void set(int index, float value);
static Handle<Object> SetValue(Handle<ExternalFloat32Array> array,
@@ -5125,6 +5144,8 @@
// Setter and getter.
inline double get_scalar(int index);
MUST_USE_RESULT inline MaybeObject* get(int index);
+ static inline Handle<Object> get(Handle<ExternalFloat64Array> array,
+ int index);
inline void set(int index, double value);
static Handle<Object> SetValue(Handle<ExternalFloat64Array> array,
@@ -5185,6 +5206,7 @@
inline ElementType get_scalar(int index);
MUST_USE_RESULT inline MaybeObject* get(int index);
+ static inline Handle<Object> get(Handle<FixedTypedArray> array, int
index);
inline void set(int index, ElementType value);
static inline ElementType from_int(int value);
@@ -5212,6 +5234,8 @@
static const InstanceType kInstanceType =
FIXED_##TYPE##_ARRAY_TYPE; \
static const char* Designator() { return #type " array";
} \
static inline MaybeObject* ToObject(Heap* heap, elementType
scalar); \
+ static inline Handle<Object> ToHandle(Isolate*
isolate, \
+ elementType
scalar); \
static inline elementType
defaultValue(); \
};
\
\
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
