Revision: 3743
Author: [email protected]
Date: Fri Jan 29 03:46:55 2010
Log: RFC: Try to be much more careful with where we skip the write barrier
by:
1. Avoid using SKIP_WRITE_BARRIER when we don't have to (smis).
2. Check and document the remaining uses of SKIP_WRITE_BARRIER.
3. Only allow GetWriteBarrierMode when in an AssertNoAllocation scope.
The only functional change should be in DeepCopyBoilerplate where we
no longer use the write barrier mode (because of allocations). I'm
running benchmarks to see if this has a measurable impact on performance.
Review URL: http://codereview.chromium.org/558041
http://code.google.com/p/v8/source/detail?r=3743
Modified:
/branches/bleeding_edge/src/builtins.cc
/branches/bleeding_edge/src/dateparser.cc
/branches/bleeding_edge/src/globals.h
/branches/bleeding_edge/src/heap.cc
/branches/bleeding_edge/src/objects-inl.h
/branches/bleeding_edge/src/objects.cc
/branches/bleeding_edge/src/objects.h
/branches/bleeding_edge/src/runtime.cc
=======================================
--- /branches/bleeding_edge/src/builtins.cc Fri Jan 29 01:52:51 2010
+++ /branches/bleeding_edge/src/builtins.cc Fri Jan 29 03:46:55 2010
@@ -247,8 +247,10 @@
Smi* len = Smi::FromInt(number_of_elements);
Object* obj = Heap::AllocateFixedArrayWithHoles(len->value());
if (obj->IsFailure()) return obj;
+
+ AssertNoAllocation no_gc;
FixedArray* elms = FixedArray::cast(obj);
- WriteBarrierMode mode = elms->GetWriteBarrierMode();
+ WriteBarrierMode mode = elms->GetWriteBarrierMode(no_gc);
// Fill in the content
for (int index = 0; index < number_of_elements; index++) {
elms->set(index, args[index+1], mode);
@@ -256,7 +258,7 @@
// Set length and elements on the array.
array->set_elements(FixedArray::cast(obj));
- array->set_length(len, SKIP_WRITE_BARRIER);
+ array->set_length(len);
return array;
}
@@ -283,8 +285,10 @@
int capacity = new_length + (new_length >> 1) + 16;
Object* obj = Heap::AllocateFixedArrayWithHoles(capacity);
if (obj->IsFailure()) return obj;
+
+ AssertNoAllocation no_gc;
FixedArray* new_elms = FixedArray::cast(obj);
- WriteBarrierMode mode = new_elms->GetWriteBarrierMode();
+ WriteBarrierMode mode = new_elms->GetWriteBarrierMode(no_gc);
// Fill out the new array with old elements.
for (int i = 0; i < len; i++) new_elms->set(i, elms->get(i), mode);
// Add the provided values.
@@ -295,7 +299,7 @@
array->set_elements(new_elms);
}
// Set the length.
- array->set_length(Smi::FromInt(new_length), SKIP_WRITE_BARRIER);
+ array->set_length(Smi::FromInt(new_length));
return array->length();
}
@@ -313,7 +317,7 @@
Object* top = elms->get(len - 1);
// Set the length.
- array->set_length(Smi::FromInt(len - 1), SKIP_WRITE_BARRIER);
+ array->set_length(Smi::FromInt(len - 1));
if (!top->IsTheHole()) {
// Delete the top element.
=======================================
--- /branches/bleeding_edge/src/dateparser.cc Mon May 25 03:05:56 2009
+++ /branches/bleeding_edge/src/dateparser.cc Fri Jan 29 03:46:55 2010
@@ -72,15 +72,9 @@
if (!Smi::IsValid(year) || !IsMonth(month) || !IsDay(day)) return false;
- output->set(YEAR,
- Smi::FromInt(year),
- SKIP_WRITE_BARRIER);
- output->set(MONTH,
- Smi::FromInt(month - 1),
- SKIP_WRITE_BARRIER); // 0-based
- output->set(DAY,
- Smi::FromInt(day),
- SKIP_WRITE_BARRIER);
+ output->set(YEAR, Smi::FromInt(year));
+ output->set(MONTH, Smi::FromInt(month - 1)); // 0-based
+ output->set(DAY, Smi::FromInt(day));
return true;
}
@@ -103,15 +97,9 @@
if (!IsHour(hour) || !IsMinute(minute) || !IsSecond(second)) return
false;
- output->set(HOUR,
- Smi::FromInt(hour),
- SKIP_WRITE_BARRIER);
- output->set(MINUTE,
- Smi::FromInt(minute),
- SKIP_WRITE_BARRIER);
- output->set(SECOND,
- Smi::FromInt(second),
- SKIP_WRITE_BARRIER);
+ output->set(HOUR, Smi::FromInt(hour));
+ output->set(MINUTE, Smi::FromInt(minute));
+ output->set(SECOND, Smi::FromInt(second));
return true;
}
@@ -121,13 +109,9 @@
if (minute_ == kNone) minute_ = 0;
int total_seconds = sign_ * (hour_ * 3600 + minute_ * 60);
if (!Smi::IsValid(total_seconds)) return false;
- output->set(UTC_OFFSET,
- Smi::FromInt(total_seconds),
- SKIP_WRITE_BARRIER);
+ output->set(UTC_OFFSET, Smi::FromInt(total_seconds));
} else {
- output->set(UTC_OFFSET,
- Heap::null_value(),
- SKIP_WRITE_BARRIER);
+ output->set_null(UTC_OFFSET);
}
return true;
}
=======================================
--- /branches/bleeding_edge/src/globals.h Fri Jan 15 05:42:32 2010
+++ /branches/bleeding_edge/src/globals.h Fri Jan 29 03:46:55 2010
@@ -204,6 +204,7 @@
class Allocation;
class Arguments;
class Assembler;
+class AssertNoAllocation;
class BreakableStatement;
class Code;
class CodeGenerator;
=======================================
--- /branches/bleeding_edge/src/heap.cc Wed Jan 27 12:14:46 2010
+++ /branches/bleeding_edge/src/heap.cc Fri Jan 29 03:46:55 2010
@@ -1729,7 +1729,7 @@
int mask = (number_string_cache()->length() >> 1) - 1;
if (number->IsSmi()) {
hash = smi_get_hash(Smi::cast(number)) & mask;
- number_string_cache()->set(hash * 2, number, SKIP_WRITE_BARRIER);
+ number_string_cache()->set(hash * 2, Smi::cast(number));
} else {
hash = double_get_hash(number->Number()) & mask;
number_string_cache()->set(hash * 2, number);
@@ -1986,8 +1986,10 @@
Object* result = Allocate(map, NEW_SPACE);
if (result->IsFailure()) return result;
+
+ AssertNoAllocation no_gc;
ConsString* cons_string = ConsString::cast(result);
- WriteBarrierMode mode = cons_string->GetWriteBarrierMode();
+ WriteBarrierMode mode = cons_string->GetWriteBarrierMode(no_gc);
cons_string->set_length(length);
cons_string->set_hash_field(String::kEmptyHashField);
cons_string->set_first(first, mode);
@@ -2285,7 +2287,7 @@
function->set_shared(shared);
function->set_prototype_or_initial_map(prototype);
function->set_context(undefined_value());
- function->set_literals(empty_fixed_array(), SKIP_WRITE_BARRIER);
+ function->set_literals(empty_fixed_array());
return function;
}
@@ -2886,8 +2888,10 @@
HeapObject::cast(obj)->set_map(src->map());
FixedArray* result = FixedArray::cast(obj);
result->set_length(len);
+
// Copy the content
- WriteBarrierMode mode = result->GetWriteBarrierMode();
+ AssertNoAllocation no_gc;
+ WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
for (int i = 0; i < len; i++) result->set(i, src->get(i), mode);
return result;
}
@@ -2905,6 +2909,7 @@
Object* value = undefined_value();
// Initialize body.
for (int index = 0; index < length; index++) {
+ ASSERT(!Heap::InNewSpace(value)); // value = undefined
array->set(index, value, SKIP_WRITE_BARRIER);
}
}
@@ -2960,6 +2965,7 @@
array->set_length(length);
Object* value = undefined_value();
for (int index = 0; index < length; index++) {
+ ASSERT(!Heap::InNewSpace(value)); // value = undefined
array->set(index, value, SKIP_WRITE_BARRIER);
}
return array;
@@ -2977,6 +2983,7 @@
// Initialize body.
Object* value = the_hole_value();
for (int index = 0; index < length; index++) {
+ ASSERT(!Heap::InNewSpace(value)); // value = the hole
array->set(index, value, SKIP_WRITE_BARRIER);
}
}
=======================================
--- /branches/bleeding_edge/src/objects-inl.h Thu Jan 28 00:46:56 2010
+++ /branches/bleeding_edge/src/objects-inl.h Fri Jan 29 03:46:55 2010
@@ -1349,7 +1349,7 @@
}
-WriteBarrierMode HeapObject::GetWriteBarrierMode() {
+WriteBarrierMode HeapObject::GetWriteBarrierMode(const
AssertNoAllocation&) {
if (Heap::InNewSpace(this)) return SKIP_WRITE_BARRIER;
return UPDATE_WRITE_BARRIER;
}
@@ -1548,9 +1548,7 @@
}
void NumberDictionary::set_requires_slow_elements() {
- set(kMaxNumberKeyIndex,
- Smi::FromInt(kRequiresSlowElementsMask),
- SKIP_WRITE_BARRIER);
+ set(kMaxNumberKeyIndex, Smi::FromInt(kRequiresSlowElementsMask));
}
@@ -2973,7 +2971,8 @@
PropertyDetails details) {
ASSERT(!key->IsString() || details.IsDeleted() || details.index() > 0);
int index = HashTable<Shape, Key>::EntryToIndex(entry);
- WriteBarrierMode mode = FixedArray::GetWriteBarrierMode();
+ AssertNoAllocation no_gc;
+ WriteBarrierMode mode = FixedArray::GetWriteBarrierMode(no_gc);
FixedArray::set(index, key, mode);
FixedArray::set(index+1, value, mode);
FixedArray::fast_set(this, index+2, details.AsSmi());
@@ -3005,10 +3004,15 @@
Expand(required_size);
}
}
+
+
+void JSArray::set_length(Smi* length) {
+ set_length(static_cast<Object*>(length), SKIP_WRITE_BARRIER);
+}
void JSArray::SetContent(FixedArray* storage) {
- set_length(Smi::FromInt(storage->length()), SKIP_WRITE_BARRIER);
+ set_length(Smi::FromInt(storage->length()));
set_elements(storage);
}
=======================================
--- /branches/bleeding_edge/src/objects.cc Wed Jan 27 05:53:19 2010
+++ /branches/bleeding_edge/src/objects.cc Fri Jan 29 03:46:55 2010
@@ -3200,8 +3200,9 @@
Object* obj = Heap::AllocateFixedArray(len0 + extra);
if (obj->IsFailure()) return obj;
// Fill in the content
+ AssertNoAllocation no_gc;
FixedArray* result = FixedArray::cast(obj);
- WriteBarrierMode mode = result->GetWriteBarrierMode();
+ WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
for (int i = 0; i < len0; i++) {
result->set(i, get(i), mode);
}
@@ -3225,10 +3226,11 @@
if (obj->IsFailure()) return obj;
FixedArray* result = FixedArray::cast(obj);
// Copy the content
+ AssertNoAllocation no_gc;
int len = length();
if (new_length < len) len = new_length;
result->set_map(map());
- WriteBarrierMode mode = result->GetWriteBarrierMode();
+ WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
for (int i = 0; i < len; i++) {
result->set(i, get(i), mode);
}
@@ -3237,7 +3239,8 @@
void FixedArray::CopyTo(int pos, FixedArray* dest, int dest_pos, int len) {
- WriteBarrierMode mode = dest->GetWriteBarrierMode();
+ AssertNoAllocation no_gc;
+ WriteBarrierMode mode = dest->GetWriteBarrierMode(no_gc);
for (int index = 0; index < len; index++) {
dest->set(dest_pos+index, get(pos+index), mode);
}
@@ -3271,8 +3274,7 @@
if (array->IsFailure()) return array;
result->set(kContentArrayIndex, array);
result->set(kEnumerationIndexIndex,
- Smi::FromInt(PropertyDetails::kInitialIndex),
- SKIP_WRITE_BARRIER);
+ Smi::FromInt(PropertyDetails::kInitialIndex));
return result;
}
@@ -4700,8 +4702,8 @@
ASSERT(target->IsHeapObject());
if (!target->IsMarked()) {
ASSERT(target->IsMap());
- contents->set(i + 1, NullDescriptorDetails, SKIP_WRITE_BARRIER);
- contents->set(i, Heap::null_value(), SKIP_WRITE_BARRIER);
+ contents->set(i + 1, NullDescriptorDetails);
+ contents->set_null(i);
ASSERT(target->prototype() == this ||
target->prototype() == real_prototype);
// Getter prototype() is read-only, set_prototype() has side
effects.
@@ -5161,7 +5163,8 @@
uint32_t len = static_cast<uint32_t>(elems->length());
for (uint32_t i = 0; i < len; i++) ASSERT(elems->get(i)->IsTheHole());
#endif
- WriteBarrierMode mode = elems->GetWriteBarrierMode();
+ AssertNoAllocation no_gc;
+ WriteBarrierMode mode = elems->GetWriteBarrierMode(no_gc);
switch (GetElementsKind()) {
case FAST_ELEMENTS: {
FixedArray* old_elements = FixedArray::cast(elements());
@@ -5228,7 +5231,7 @@
Object* JSArray::Initialize(int capacity) {
ASSERT(capacity >= 0);
- set_length(Smi::FromInt(0), SKIP_WRITE_BARRIER);
+ set_length(Smi::FromInt(0));
FixedArray* new_elements;
if (capacity == 0) {
new_elements = Heap::empty_fixed_array();
@@ -5288,7 +5291,7 @@
for (int i = value; i < old_length; i++) {
FixedArray::cast(elements())->set_the_hole(i);
}
- JSArray::cast(this)->set_length(smi_length,
SKIP_WRITE_BARRIER);
+ JSArray::cast(this)->set_length(Smi::cast(smi_length));
}
return this;
}
@@ -5298,8 +5301,9 @@
!ShouldConvertToSlowElements(new_capacity)) {
Object* obj = Heap::AllocateFixedArrayWithHoles(new_capacity);
if (obj->IsFailure()) return obj;
- if (IsJSArray()) JSArray::cast(this)->set_length(smi_length,
-
SKIP_WRITE_BARRIER);
+ if (IsJSArray()) {
+ JSArray::cast(this)->set_length(Smi::cast(smi_length));
+ }
SetFastElements(FixedArray::cast(obj));
return this;
}
@@ -5318,7 +5322,7 @@
static_cast<uint32_t>(JSArray::cast(this)->length()->Number());
element_dictionary()->RemoveNumberEntries(value, old_length);
}
- JSArray::cast(this)->set_length(smi_length, SKIP_WRITE_BARRIER);
+ JSArray::cast(this)->set_length(Smi::cast(smi_length));
}
return this;
}
@@ -5343,8 +5347,7 @@
Object* obj = Heap::AllocateFixedArray(1);
if (obj->IsFailure()) return obj;
FixedArray::cast(obj)->set(0, len);
- if (IsJSArray()) JSArray::cast(this)->set_length(Smi::FromInt(1),
- SKIP_WRITE_BARRIER);
+ if (IsJSArray()) JSArray::cast(this)->set_length(Smi::FromInt(1));
set_elements(FixedArray::cast(obj));
return this;
}
@@ -5614,8 +5617,7 @@
CHECK(Array::IndexFromObject(JSArray::cast(this)->length(),
&array_length));
if (index >= array_length) {
- JSArray::cast(this)->set_length(Smi::FromInt(index + 1),
- SKIP_WRITE_BARRIER);
+ JSArray::cast(this)->set_length(Smi::FromInt(index + 1));
}
}
return value;
@@ -5631,8 +5633,9 @@
Object* obj = Heap::AllocateFixedArrayWithHoles(new_capacity);
if (obj->IsFailure()) return obj;
SetFastElements(FixedArray::cast(obj));
- if (IsJSArray()) JSArray::cast(this)->set_length(Smi::FromInt(index
+ 1),
- SKIP_WRITE_BARRIER);
+ if (IsJSArray()) {
+ JSArray::cast(this)->set_length(Smi::FromInt(index + 1));
+ }
FixedArray::cast(elements())->set(index, value);
return value;
}
@@ -6129,7 +6132,8 @@
void Dictionary<Shape, Key>::CopyValuesTo(FixedArray* elements) {
int pos = 0;
int capacity = HashTable<Shape, Key>::Capacity();
- WriteBarrierMode mode = elements->GetWriteBarrierMode();
+ AssertNoAllocation no_gc;
+ WriteBarrierMode mode = elements->GetWriteBarrierMode(no_gc);
for (int i = 0; i < capacity; i++) {
Object* k = Dictionary<Shape, Key>::KeyAt(i);
if (Dictionary<Shape, Key>::IsKey(k)) {
@@ -6500,7 +6504,7 @@
for (int i = 0; i < length; i++) {
if (!FixedArray::cast(elements())->get(i)->IsTheHole()) {
if (storage != NULL) {
- storage->set(counter, Smi::FromInt(i), SKIP_WRITE_BARRIER);
+ storage->set(counter, Smi::FromInt(i));
}
counter++;
}
@@ -6512,7 +6516,7 @@
int length = PixelArray::cast(elements())->length();
while (counter < length) {
if (storage != NULL) {
- storage->set(counter, Smi::FromInt(counter), SKIP_WRITE_BARRIER);
+ storage->set(counter, Smi::FromInt(counter));
}
counter++;
}
@@ -6529,7 +6533,7 @@
int length = ExternalArray::cast(elements())->length();
while (counter < length) {
if (storage != NULL) {
- storage->set(counter, Smi::FromInt(counter), SKIP_WRITE_BARRIER);
+ storage->set(counter, Smi::FromInt(counter));
}
counter++;
}
@@ -6554,7 +6558,7 @@
String* str = String::cast(val);
if (storage) {
for (int i = 0; i < str->length(); i++) {
- storage->set(counter + i, Smi::FromInt(i), SKIP_WRITE_BARRIER);
+ storage->set(counter + i, Smi::FromInt(i));
}
}
counter += str->length();
@@ -6886,8 +6890,10 @@
Object* obj = Allocate(nof * 2);
if (obj->IsFailure()) return obj;
+
+ AssertNoAllocation no_gc;
HashTable* table = HashTable::cast(obj);
- WriteBarrierMode mode = table->GetWriteBarrierMode();
+ WriteBarrierMode mode = table->GetWriteBarrierMode(no_gc);
// Copy prefix to new array.
for (int i = kPrefixStartIndex;
@@ -7134,7 +7140,7 @@
// Split elements into defined, undefined and the_hole, in that order.
// Only count locations for undefined and the hole, and fill them
afterwards.
- WriteBarrierMode write_barrier = elements->GetWriteBarrierMode();
+ WriteBarrierMode write_barrier = elements->GetWriteBarrierMode(no_alloc);
unsigned int undefs = limit;
unsigned int holes = limit;
// Assume most arrays contain no holes and undefined values, so minimize
the
@@ -7629,7 +7635,7 @@
if (obj->IsFailure()) return obj;
FixedArray* iteration_order = FixedArray::cast(obj);
for (int i = 0; i < length; i++) {
- iteration_order->set(i, Smi::FromInt(i), SKIP_WRITE_BARRIER);
+ iteration_order->set(i, Smi::FromInt(i));
}
// Allocate array with enumeration order.
@@ -7642,9 +7648,7 @@
int pos = 0;
for (int i = 0; i < capacity; i++) {
if (Dictionary<Shape, Key>::IsKey(Dictionary<Shape, Key>::KeyAt(i))) {
- enumeration_order->set(pos++,
- Smi::FromInt(DetailsAt(i).index()),
- SKIP_WRITE_BARRIER);
+ enumeration_order->set(pos++, Smi::FromInt(DetailsAt(i).index()));
}
}
@@ -7655,9 +7659,7 @@
for (int i = 0; i < length; i++) {
int index = Smi::cast(iteration_order->get(i))->value();
int enum_index = PropertyDetails::kInitialIndex + i;
- enumeration_order->set(index,
- Smi::FromInt(enum_index),
- SKIP_WRITE_BARRIER);
+ enumeration_order->set(index, Smi::FromInt(enum_index));
}
// Update the dictionary with new indices.
@@ -7805,8 +7807,7 @@
Object* max_index_object = get(kMaxNumberKeyIndex);
if (!max_index_object->IsSmi() || max_number_key() < key) {
FixedArray::set(kMaxNumberKeyIndex,
- Smi::FromInt(key << kRequiresSlowElementsTagSize),
- SKIP_WRITE_BARRIER);
+ Smi::FromInt(key << kRequiresSlowElementsTagSize));
}
}
@@ -7897,9 +7898,7 @@
PropertyDetails details = DetailsAt(i);
if (details.IsDeleted() || details.IsDontEnum()) continue;
storage->set(index, k);
- sort_array->set(index,
- Smi::FromInt(details.index()),
- SKIP_WRITE_BARRIER);
+ sort_array->set(index, Smi::FromInt(details.index()));
index++;
}
}
=======================================
--- /branches/bleeding_edge/src/objects.h Thu Jan 28 00:46:56 2010
+++ /branches/bleeding_edge/src/objects.h Fri Jan 29 03:46:55 2010
@@ -1023,8 +1023,12 @@
// Casting.
static inline HeapObject* cast(Object* obj);
- // Return the write barrier mode for this.
- inline WriteBarrierMode GetWriteBarrierMode();
+ // Return the write barrier mode for this. Callers of this function
+ // must be able to present a reference to an AssertNoAllocation
+ // object as a sign that they are not going to use this function
+ // from code that allocates and thus invalidates the returned write
+ // barrier mode.
+ inline WriteBarrierMode GetWriteBarrierMode(const AssertNoAllocation&);
// Dispatched behavior.
void HeapObjectShortPrint(StringStream* accumulator);
@@ -4475,6 +4479,10 @@
// [length]: The length property.
DECL_ACCESSORS(length, Object)
+ // Overload the length setter to skip write barrier when the length
+ // is set to a smi. This matches the set function on FixedArray.
+ inline void set_length(Smi* length);
+
Object* JSArrayUpdateLengthFromIndex(uint32_t index, Object* value);
// Initialize the array with the given capacity. The function may
=======================================
--- /branches/bleeding_edge/src/runtime.cc Fri Jan 29 01:52:51 2010
+++ /branches/bleeding_edge/src/runtime.cc Fri Jan 29 03:46:55 2010
@@ -107,25 +107,23 @@
// Deep copy local properties.
if (copy->HasFastProperties()) {
FixedArray* properties = copy->properties();
- WriteBarrierMode mode = properties->GetWriteBarrierMode();
for (int i = 0; i < properties->length(); i++) {
Object* value = properties->get(i);
if (value->IsJSObject()) {
- JSObject* jsObject = JSObject::cast(value);
- result = DeepCopyBoilerplate(jsObject);
+ JSObject* js_object = JSObject::cast(value);
+ result = DeepCopyBoilerplate(js_object);
if (result->IsFailure()) return result;
- properties->set(i, result, mode);
+ properties->set(i, result);
}
}
- mode = copy->GetWriteBarrierMode();
int nof = copy->map()->inobject_properties();
for (int i = 0; i < nof; i++) {
Object* value = copy->InObjectPropertyAt(i);
if (value->IsJSObject()) {
- JSObject* jsObject = JSObject::cast(value);
- result = DeepCopyBoilerplate(jsObject);
+ JSObject* js_object = JSObject::cast(value);
+ result = DeepCopyBoilerplate(js_object);
if (result->IsFailure()) return result;
- copy->InObjectPropertyAtPut(i, result, mode);
+ copy->InObjectPropertyAtPut(i, result);
}
}
} else {
@@ -135,20 +133,20 @@
copy->GetLocalPropertyNames(names, 0);
for (int i = 0; i < names->length(); i++) {
ASSERT(names->get(i)->IsString());
- String* keyString = String::cast(names->get(i));
+ String* key_string = String::cast(names->get(i));
PropertyAttributes attributes =
- copy->GetLocalPropertyAttribute(keyString);
+ copy->GetLocalPropertyAttribute(key_string);
// Only deep copy fields from the object literal expression.
// In particular, don't try to copy the length attribute of
// an array.
if (attributes != NONE) continue;
- Object* value = copy->GetProperty(keyString, &attributes);
+ Object* value = copy->GetProperty(key_string, &attributes);
ASSERT(!value->IsFailure());
if (value->IsJSObject()) {
- JSObject* jsObject = JSObject::cast(value);
- result = DeepCopyBoilerplate(jsObject);
+ JSObject* js_object = JSObject::cast(value);
+ result = DeepCopyBoilerplate(js_object);
if (result->IsFailure()) return result;
- result = copy->SetProperty(keyString, result, NONE);
+ result = copy->SetProperty(key_string, result, NONE);
if (result->IsFailure()) return result;
}
}
@@ -160,14 +158,13 @@
switch (copy->GetElementsKind()) {
case JSObject::FAST_ELEMENTS: {
FixedArray* elements = FixedArray::cast(copy->elements());
- WriteBarrierMode mode = elements->GetWriteBarrierMode();
for (int i = 0; i < elements->length(); i++) {
Object* value = elements->get(i);
if (value->IsJSObject()) {
- JSObject* jsObject = JSObject::cast(value);
- result = DeepCopyBoilerplate(jsObject);
+ JSObject* js_object = JSObject::cast(value);
+ result = DeepCopyBoilerplate(js_object);
if (result->IsFailure()) return result;
- elements->set(i, result, mode);
+ elements->set(i, result);
}
}
break;
@@ -180,8 +177,8 @@
if (element_dictionary->IsKey(k)) {
Object* value = element_dictionary->ValueAt(i);
if (value->IsJSObject()) {
- JSObject* jsObject = JSObject::cast(value);
- result = DeepCopyBoilerplate(jsObject);
+ JSObject* js_object = JSObject::cast(value);
+ result = DeepCopyBoilerplate(js_object);
if (result->IsFailure()) return result;
element_dictionary->ValueAtPut(i, result);
}
@@ -1439,6 +1436,8 @@
literals->set(JSFunction::kLiteralGlobalContextIndex,
context->global_context());
}
+ // It's okay to skip the write barrier here because the literals
+ // are guaranteed to be in old space.
target->set_literals(*literals, SKIP_WRITE_BARRIER);
}
@@ -4717,7 +4716,9 @@
if (obj->IsFailure()) return obj;
FixedArray* array = FixedArray::cast(obj);
ASSERT(array->length() == length);
- WriteBarrierMode mode = array->GetWriteBarrierMode();
+
+ AssertNoAllocation no_gc;
+ WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
for (int i = 0; i < length; i++) {
array->set(i, frame->GetParameter(i), mode);
}
@@ -4742,10 +4743,13 @@
// Allocate the fixed array.
Object* obj = Heap::AllocateRawFixedArray(length);
if (obj->IsFailure()) return obj;
+
+ AssertNoAllocation no_gc;
reinterpret_cast<Array*>(obj)->set_map(Heap::fixed_array_map());
FixedArray* array = FixedArray::cast(obj);
array->set_length(length);
- WriteBarrierMode mode = array->GetWriteBarrierMode();
+
+ WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
for (int i = 0; i < length; i++) {
array->set(i, *--parameters, mode);
}
@@ -6030,7 +6034,7 @@
to->SetContent(FixedArray::cast(from->elements()));
to->set_length(from->length());
from->SetContent(Heap::empty_fixed_array());
- from->set_length(0);
+ from->set_length(Smi::FromInt(0));
return to;
}
@@ -6073,9 +6077,7 @@
} else {
Handle<FixedArray> single_interval = Factory::NewFixedArray(2);
// -1 means start of array.
- single_interval->set(0,
- Smi::FromInt(-1),
- SKIP_WRITE_BARRIER);
+ single_interval->set(0, Smi::FromInt(-1));
uint32_t actual_length =
static_cast<uint32_t>(array->elements()->length());
uint32_t min_length = actual_length < length ? actual_length : length;
Handle<Object> length_object =
@@ -7448,7 +7450,9 @@
const int length = frame->GetProvidedParametersCount();
Handle<JSObject> arguments = Factory::NewArgumentsObject(function,
length);
Handle<FixedArray> array = Factory::NewFixedArray(length);
- WriteBarrierMode mode = array->GetWriteBarrierMode();
+
+ AssertNoAllocation no_gc;
+ WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
for (int i = 0; i < length; i++) {
array->set(i, frame->GetParameter(i), mode);
}
@@ -8032,7 +8036,7 @@
if (cursor + 2 < elements->length()) {
elements->set(cursor++, recv);
elements->set(cursor++, fun);
- elements->set(cursor++, offset, SKIP_WRITE_BARRIER);
+ elements->set(cursor++, offset);
} else {
HandleScope scope;
Handle<Object> recv_handle(recv);
@@ -8045,8 +8049,7 @@
iter.Advance();
}
- result->set_length(Smi::FromInt(cursor), SKIP_WRITE_BARRIER);
-
+ result->set_length(Smi::FromInt(cursor));
return *result;
}
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
