Revision: 16900
Author: [email protected]
Date: Mon Sep 23 16:53:59 2013 UTC
Log: Revert "Handlify JSObject::MigrateInstance and friends."
This is reverted due to mozilla/ecma/Date/15.9.5.9 failing on Windows.
[email protected]
Review URL: https://codereview.chromium.org/24374002
http://code.google.com/p/v8/source/detail?r=16900
Modified:
/branches/bleeding_edge/src/hydrogen.cc
/branches/bleeding_edge/src/objects-inl.h
/branches/bleeding_edge/src/objects.cc
/branches/bleeding_edge/src/objects.h
=======================================
--- /branches/bleeding_edge/src/hydrogen.cc Mon Sep 23 15:02:25 2013 UTC
+++ /branches/bleeding_edge/src/hydrogen.cc Mon Sep 23 16:53:59 2013 UTC
@@ -4106,7 +4106,7 @@
int* max_properties) {
if (boilerplate->map()->is_deprecated()) {
Handle<Object> result = JSObject::TryMigrateInstance(boilerplate);
- if (result.is_null()) return false;
+ if (result->IsSmi()) return false;
}
ASSERT(max_depth >= 0 && *max_properties >= 0);
=======================================
--- /branches/bleeding_edge/src/objects-inl.h Mon Sep 23 15:02:25 2013 UTC
+++ /branches/bleeding_edge/src/objects-inl.h Mon Sep 23 16:53:59 2013 UTC
@@ -285,13 +285,14 @@
MaybeObject* Object::AllocateNewStorageFor(Heap* heap,
- Representation representation) {
+ Representation representation,
+ PretenureFlag tenure) {
if (!FLAG_track_double_fields) return this;
if (!representation.IsDouble()) return this;
if (IsUninitialized()) {
- return heap->AllocateHeapNumber(0);
+ return heap->AllocateHeapNumber(0, tenure);
}
- return heap->AllocateHeapNumber(Number());
+ return heap->AllocateHeapNumber(Number(), tenure);
}
@@ -1539,6 +1540,19 @@
return this;
}
+
+
+MaybeObject* JSObject::TryMigrateInstance() {
+ Map* new_map = map()->CurrentMapForDeprecated();
+ if (new_map == NULL) return Smi::FromInt(0);
+ Map* original_map = map();
+ MaybeObject* maybe_result = MigrateToMap(new_map);
+ JSObject* result;
+ if (FLAG_trace_migration && maybe_result->To(&result)) {
+ PrintInstanceMigration(stdout, original_map, result->map());
+ }
+ return maybe_result;
+}
Handle<String> JSObject::ExpectedTransitionKey(Handle<Map> map) {
=======================================
--- /branches/bleeding_edge/src/objects.cc Mon Sep 23 15:02:25 2013 UTC
+++ /branches/bleeding_edge/src/objects.cc Mon Sep 23 16:53:59 2013 UTC
@@ -2268,6 +2268,11 @@
// Otherwise, properties will need to be moved to the backing store.
return true;
}
+
+
+void JSObject::MigrateToMap(Handle<JSObject> object, Handle<Map> new_map) {
+ CALL_HEAP_FUNCTION_VOID(object->GetIsolate(),
object->MigrateToMap(*new_map));
+}
// To migrate an instance to a map:
@@ -2285,24 +2290,25 @@
// to temporarily store the inobject properties.
// * If there are properties left in the backing store, install the
backing
// store.
-void JSObject::MigrateToMap(Handle<JSObject> object, Handle<Map> new_map) {
- Isolate* isolate = object->GetIsolate();
- Handle<Map> old_map(object->map());
+MaybeObject* JSObject::MigrateToMap(Map* new_map) {
+ Heap* heap = GetHeap();
+ Map* old_map = map();
int number_of_fields = new_map->NumberOfFields();
int inobject = new_map->inobject_properties();
int unused = new_map->unused_property_fields();
- // Nothing to do if no functions were converted to fields and no smis
were
- // converted to doubles.
+ // Nothing to do if no functions were converted to fields.
if (!old_map->InstancesNeedRewriting(
- *new_map, number_of_fields, inobject, unused)) {
- object->set_map(*new_map);
- return;
+ new_map, number_of_fields, inobject, unused)) {
+ set_map(new_map);
+ return this;
}
int total_size = number_of_fields + unused;
int external = total_size - inobject;
- Handle<FixedArray> array = isolate->factory()->NewFixedArray(total_size);
+ FixedArray* array;
+ MaybeObject* maybe_array = heap->AllocateFixedArray(total_size);
+ if (!maybe_array->To(&array)) return maybe_array;
DescriptorArray* old_descriptors = old_map->instance_descriptors();
DescriptorArray* new_descriptors = new_map->instance_descriptors();
@@ -2318,51 +2324,55 @@
}
ASSERT(old_details.type() == CONSTANT ||
old_details.type() == FIELD);
- Object* raw_value = old_details.type() == CONSTANT
+ Object* value = old_details.type() == CONSTANT
? old_descriptors->GetValue(i)
- : object->RawFastPropertyAt(old_descriptors->GetFieldIndex(i));
- Handle<Object> value(raw_value, isolate);
+ : RawFastPropertyAt(old_descriptors->GetFieldIndex(i));
if (FLAG_track_double_fields &&
!old_details.representation().IsDouble() &&
details.representation().IsDouble()) {
- if (old_details.representation().IsNone()) {
- value = handle(Smi::FromInt(0), isolate);
- }
- value = NewStorageFor(isolate, value, details.representation());
+ if (old_details.representation().IsNone()) value = Smi::FromInt(0);
+ // Objects must be allocated in the old object space, since the
+ // overall number of HeapNumbers needed for the conversion might
+ // exceed the capacity of new space, and we would fail repeatedly
+ // trying to migrate the instance.
+ MaybeObject* maybe_storage =
+ value->AllocateNewStorageFor(heap, details.representation(),
TENURED);
+ if (!maybe_storage->To(&value)) return maybe_storage;
}
ASSERT(!(FLAG_track_double_fields &&
details.representation().IsDouble() &&
value->IsSmi()));
int target_index = new_descriptors->GetFieldIndex(i) - inobject;
if (target_index < 0) target_index += total_size;
- array->set(target_index, *value);
+ array->set(target_index, value);
}
- // From here on we cannot fail and we shouldn't GC anymore.
- DisallowHeapAllocation no_allocation;
+ // From here on we cannot fail anymore.
// Copy (real) inobject properties. If necessary, stop at
number_of_fields to
// avoid overwriting |one_pointer_filler_map|.
int limit = Min(inobject, number_of_fields);
for (int i = 0; i < limit; i++) {
- object->FastPropertyAtPut(i, array->get(external + i));
+ FastPropertyAtPut(i, array->get(external + i));
}
// Create filler object past the new instance size.
int new_instance_size = new_map->instance_size();
int instance_size_delta = old_map->instance_size() - new_instance_size;
ASSERT(instance_size_delta >= 0);
- Address address = object->address() + new_instance_size;
- isolate->heap()->CreateFillerObjectAt(address, instance_size_delta);
+ Address address = this->address() + new_instance_size;
+ heap->CreateFillerObjectAt(address, instance_size_delta);
// If there are properties in the new backing store, trim it to the
correct
// size and install the backing store into the object.
if (external > 0) {
- RightTrimFixedArray<FROM_MUTATOR>(isolate->heap(), *array, inobject);
- object->set_properties(*array);
+ RightTrimFixedArray<FROM_MUTATOR>(heap, array, inobject);
+ set_properties(array);
}
- object->set_map(*new_map);
+ set_map(new_map);
+
+ return this;
}
@@ -3748,13 +3758,7 @@
Handle<Object> JSObject::TryMigrateInstance(Handle<JSObject> object) {
- Map* new_map = object->map()->CurrentMapForDeprecated();
- if (new_map == NULL) return Handle<Object>();
- Handle<Map> original_map(object->map());
- JSObject::MigrateToMap(object, handle(new_map));
- if (FLAG_trace_migration) {
- object->PrintInstanceMigration(stdout, *original_map, object->map());
- }
+ MigrateInstance(object);
return object;
}
=======================================
--- /branches/bleeding_edge/src/objects.h Mon Sep 23 15:02:25 2013 UTC
+++ /branches/bleeding_edge/src/objects.h Mon Sep 23 16:53:59 2013 UTC
@@ -1440,7 +1440,8 @@
}
inline MaybeObject* AllocateNewStorageFor(Heap* heap,
- Representation representation);
+ Representation representation,
+ PretenureFlag tenure =
NOT_TENURED);
// Returns true if the object is of the correct type to be used as a
// implementation of a JSObject's elements.
@@ -2172,13 +2173,10 @@
// passed map. This also extends the property backing store if necessary.
static void AllocateStorageForMap(Handle<JSObject> object, Handle<Map>
map);
- // Migrates the given object to a map whose field representations are the
- // lowest upper bound of all known representations for that field.
static void MigrateInstance(Handle<JSObject> instance);
- // Migrates the given object only if the target map is already available,
- // or returns an empty handle if such a map is not yet available.
static Handle<Object> TryMigrateInstance(Handle<JSObject> instance);
+ inline MUST_USE_RESULT MaybeObject* TryMigrateInstance();
// Can cause GC.
MUST_USE_RESULT MaybeObject* SetLocalPropertyIgnoreAttributesTrampoline(
@@ -2472,8 +2470,8 @@
MUST_USE_RESULT MaybeObject* TransitionElementsKind(ElementsKind
to_kind);
MUST_USE_RESULT MaybeObject* UpdateAllocationSite(ElementsKind to_kind);
- // TODO(mstarzinger): Both public because of
ConvertAnsSetLocalProperty().
static void MigrateToMap(Handle<JSObject> object, Handle<Map> new_map);
+ MUST_USE_RESULT MaybeObject* MigrateToMap(Map* new_map);
static void GeneralizeFieldRepresentation(Handle<JSObject> object,
int modify_index,
Representation
new_representation,
--
--
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/groups/opt_out.
