Revision: 8195
Author: [email protected]
Date: Tue Jun 7 02:28:08 2011
Log: Call a stub for the write barrier on ARM. This is a step
towards incremental marking on ARM.
Review URL: http://codereview.chromium.org/7113012
http://code.google.com/p/v8/source/detail?r=8195
Modified:
/branches/experimental/gc/src/arm/code-stubs-arm.cc
/branches/experimental/gc/src/arm/full-codegen-arm.cc
/branches/experimental/gc/src/arm/ic-arm.cc
/branches/experimental/gc/src/arm/lithium-codegen-arm.cc
/branches/experimental/gc/src/arm/macro-assembler-arm.cc
/branches/experimental/gc/src/arm/macro-assembler-arm.h
/branches/experimental/gc/src/arm/stub-cache-arm.cc
/branches/experimental/gc/src/ia32/code-stubs-ia32.cc
/branches/experimental/gc/src/ia32/code-stubs-ia32.h
/branches/experimental/gc/src/ia32/macro-assembler-ia32.cc
/branches/experimental/gc/src/ia32/macro-assembler-ia32.h
=======================================
--- /branches/experimental/gc/src/arm/code-stubs-arm.cc Wed May 25 07:05:16
2011
+++ /branches/experimental/gc/src/arm/code-stubs-arm.cc Tue Jun 7 02:28:08
2011
@@ -4403,6 +4403,7 @@
RegExpImpl::kLastSubjectOffset,
r2,
r7,
+ kLRHasNotBeenSaved,
kDontSaveFPRegs);
__ str(subject,
FieldMemOperand(last_match_info_elements,
@@ -4411,6 +4412,7 @@
RegExpImpl::kLastInputOffset,
subject,
r7,
+ kLRHasNotBeenSaved,
kDontSaveFPRegs);
// Get the static offsets vector filled by the native regexp code.
@@ -6446,6 +6448,19 @@
__ mov(result, Operand(0));
__ Ret();
}
+
+
+// Takes the input in 3 registers: address_ value_ and object_. A pointer
to
+// the value has just been written into the object, now this stub makes
sure
+// we keep the GC informed. The word in the object where the value has
been
+// written is in the address register.
+void RecordWriteStub::Generate(MacroAssembler* masm) {
+ if (remembered_set_action_ == EMIT_REMEMBERED_SET) {
+ __ RememberedSetHelper(
+ address_, value_, save_fp_regs_mode_,
MacroAssembler::kReturnAtEnd);
+ }
+ __ Ret();
+}
#undef __
=======================================
--- /branches/experimental/gc/src/arm/full-codegen-arm.cc Wed May 25
07:05:16 2011
+++ /branches/experimental/gc/src/arm/full-codegen-arm.cc Tue Jun 7
02:28:08 2011
@@ -203,7 +203,8 @@
__ str(r0, target);
// Update the write barrier.
- __ RecordWriteContextSlot(cp, target.offset(), r0, r3,
kDontSaveFPRegs);
+ __ RecordWriteContextSlot(
+ cp, target.offset(), r0, r3, kLRHasBeenSaved, kDontSaveFPRegs);
}
}
}
@@ -648,8 +649,12 @@
// Emit the write barrier code if the location is in the heap.
if (dst->type() == Slot::CONTEXT) {
- __ RecordWriteContextSlot(
- scratch1, location.offset(), src, scratch2, kDontSaveFPRegs);
+ __ RecordWriteContextSlot(scratch1,
+ location.offset(),
+ src,
+ scratch2,
+ kLRHasBeenSaved,
+ kDontSaveFPRegs);
}
}
@@ -729,6 +734,7 @@
target.offset(),
result_register(),
r2,
+ kLRHasBeenSaved,
kDontSaveFPRegs,
EMIT_REMEMBERED_SET,
OMIT_SMI_CHECK);
@@ -1553,7 +1559,8 @@
// Update the write barrier for the array store with r0 as the scratch
// register.
- __ RecordWriteField(r1, offset, result_register(), r2,
kDontSaveFPRegs);
+ __ RecordWriteField(
+ r1, offset, result_register(), r2, kLRHasBeenSaved,
kDontSaveFPRegs);
PrepareForBailoutForId(expr->GetIdForElement(i), NO_REGISTERS);
}
@@ -1935,7 +1942,8 @@
MemOperand target = ContextOperand(r1, slot->index());
__ str(r0, target);
__ mov(r3, r0); // Preserve the stored value in r0.
- __ RecordWriteContextSlot(r1, target.offset(), r3, r2,
kDontSaveFPRegs);
+ __ RecordWriteContextSlot(
+ r1, target.offset(), r3, r2, kLRHasBeenSaved, kDontSaveFPRegs);
break;
}
case Slot::LOOKUP:
@@ -1965,7 +1973,8 @@
// The value of the assignment is in result_register().
RecordWrite
// clobbers its second and third register arguments.
__ mov(r3, result_register());
- __ RecordWriteContextSlot(r1, target.offset(), r3, r2,
kDontSaveFPRegs);
+ __ RecordWriteContextSlot(
+ r1, target.offset(), r3, r2, kLRHasBeenSaved, kDontSaveFPRegs);
break;
}
@@ -2969,7 +2978,8 @@
// Update the write barrier. Save the value as it will be
// overwritten by the write barrier code and is needed afterward.
__ mov(r2, r0);
- __ RecordWriteField(r1, JSValue::kValueOffset, r2, r3, kDontSaveFPRegs);
+ __ RecordWriteField(
+ r1, JSValue::kValueOffset, r2, r3, kLRHasBeenSaved, kDontSaveFPRegs);
__ bind(&done);
context()->Plug(r0);
@@ -3265,8 +3275,10 @@
// Possible optimization: do a check that both values are Smis
// (or them and test against Smi mask.)
- __ RememberedSetHelper(index1, scratch2, kDontSaveFPRegs);
- __ RememberedSetHelper(index2, scratch2, kDontSaveFPRegs);
+ __ RememberedSetHelper(
+ index1, scratch2, kDontSaveFPRegs,
MacroAssembler::kFallThroughAtEnd);
+ __ RememberedSetHelper(
+ index2, scratch2, kDontSaveFPRegs,
MacroAssembler::kFallThroughAtEnd);
__ bind(&no_remembered_set);
// We are done. Drop elements from the stack, and return undefined.
=======================================
--- /branches/experimental/gc/src/arm/ic-arm.cc Wed May 25 07:05:16 2011
+++ /branches/experimental/gc/src/arm/ic-arm.cc Tue Jun 7 02:28:08 2011
@@ -209,7 +209,8 @@
// Update the write barrier. Make sure not to clobber the value.
__ mov(scratch1, value);
- __ RecordWrite(elements, scratch2, scratch1, kDontSaveFPRegs);
+ __ RecordWrite(
+ elements, scratch2, scratch1, kLRHasNotBeenSaved, kDontSaveFPRegs);
}
@@ -1302,6 +1303,7 @@
__ RecordWrite(elements,
address,
scratch_value,
+ kLRHasNotBeenSaved,
kDontSaveFPRegs,
EMIT_REMEMBERED_SET,
OMIT_SMI_CHECK);
=======================================
--- /branches/experimental/gc/src/arm/lithium-codegen-arm.cc Wed May 25
07:05:16 2011
+++ /branches/experimental/gc/src/arm/lithium-codegen-arm.cc Tue Jun 7
02:28:08 2011
@@ -208,7 +208,8 @@
MemOperand target = ContextOperand(cp, slot->index());
__ str(r0, target);
// Update the write barrier. This clobbers r3 and r0.
- __ RecordWriteContextSlot(cp, target.offset(), r0, r3,
kSaveFPRegs);
+ __ RecordWriteContextSlot(
+ cp, target.offset(), r0, r3, kLRHasBeenSaved, kSaveFPRegs);
}
}
Comment(";;; End allocate local context");
@@ -2364,8 +2365,12 @@
MemOperand target = ContextOperand(context, instr->slot_index());
__ str(value, target);
if (instr->needs_write_barrier()) {
- __ RecordWriteContextSlot(
- context, target.offset(), value, scratch0(), kSaveFPRegs);
+ __ RecordWriteContextSlot(context,
+ target.offset(),
+ value,
+ scratch0(),
+ kLRHasBeenSaved,
+ kSaveFPRegs);
}
}
@@ -3305,7 +3310,8 @@
__ str(value, FieldMemOperand(object, offset));
if (instr->needs_write_barrier()) {
// Update the write barrier for the object for in-object properties.
- __ RecordWriteField(object, offset, value, scratch, kSaveFPRegs);
+ __ RecordWriteField(
+ object, offset, value, scratch, kLRHasBeenSaved, kSaveFPRegs);
}
} else {
__ ldr(scratch, FieldMemOperand(object, JSObject::kPropertiesOffset));
@@ -3313,7 +3319,8 @@
if (instr->needs_write_barrier()) {
// Update the write barrier for the properties array.
// object is used as a scratch register.
- __ RecordWriteField(scratch, offset, value, object, kSaveFPRegs);
+ __ RecordWriteField(
+ scratch, offset, value, object, kLRHasBeenSaved, kSaveFPRegs);
}
}
}
@@ -3359,7 +3366,7 @@
if (instr->hydrogen()->NeedsWriteBarrier()) {
// Compute address of modified element and store it into key register.
__ add(key, scratch, Operand(FixedArray::kHeaderSize));
- __ RecordWrite(elements, key, value, kSaveFPRegs);
+ __ RecordWrite(elements, key, value, kLRHasBeenSaved, kSaveFPRegs);
}
}
=======================================
--- /branches/experimental/gc/src/arm/macro-assembler-arm.cc Mon Jun 6
04:22:38 2011
+++ /branches/experimental/gc/src/arm/macro-assembler-arm.cc Tue Jun 7
02:28:08 2011
@@ -482,6 +482,7 @@
int offset,
Register value,
Register dst,
+ LinkRegisterStatus lr_status,
SaveFPRegsMode save_fp,
RememberedSetAction remembered_set_action,
SmiCheck smi_check) {
@@ -506,8 +507,13 @@
bind(&ok);
}
- RecordWrite(
- object, dst, value, save_fp, remembered_set_action, OMIT_SMI_CHECK);
+ RecordWrite(object,
+ dst,
+ value,
+ lr_status,
+ save_fp,
+ remembered_set_action,
+ OMIT_SMI_CHECK);
bind(&done);
@@ -525,38 +531,60 @@
// tag is shifted away.
void MacroAssembler::RecordWrite(Register object,
Register address,
- Register scratch,
+ Register value,
+ LinkRegisterStatus lr_status,
SaveFPRegsMode fp_mode,
RememberedSetAction remembered_set_action,
SmiCheck smi_check) {
// The compiled code assumes that record write doesn't change the
// context register, so we check that none of the clobbered
// registers are cp.
- ASSERT(!address.is(cp) && !scratch.is(cp));
+ ASSERT(!address.is(cp) && !value.is(cp));
Label done;
- // First, test that the object is not in the new space. We cannot set
- // region marks for new space pages.
- InNewSpace(object, scratch, eq, &done);
+ if (smi_check == INLINE_SMI_CHECK) {
+ ASSERT_EQ(0, kSmiTag);
+ tst(value, Operand(kSmiTagMask));
+ b(eq, &done);
+ }
+
+ CheckPageFlag(value,
+ value, // Used as scratch.
+ MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING,
+ eq,
+ &done);
+ CheckPageFlag(object,
+ value, // Used as scratch.
+ MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING,
+ eq,
+ &done);
// Record the actual write.
- RememberedSetHelper(address, scratch, fp_mode);
+ if (lr_status == kLRHasNotBeenSaved) {
+ push(lr);
+ }
+ RecordWriteStub stub(object, value, address, remembered_set_action,
fp_mode);
+ CallStub(&stub);
+ if (lr_status == kLRHasNotBeenSaved) {
+ pop(lr);
+ }
bind(&done);
- // Clobber all input registers when running with the debug-code flag
+ // Clobber clobbered registers when running with the debug-code flag
// turned on to provoke errors.
if (emit_debug_code()) {
mov(address, Operand(BitCast<int32_t>(kZapValue + 12)));
- mov(scratch, Operand(BitCast<int32_t>(kZapValue + 16)));
+ mov(value, Operand(BitCast<int32_t>(kZapValue + 16)));
}
}
void MacroAssembler::RememberedSetHelper(Register address,
Register scratch,
- SaveFPRegsMode fp_mode) {
+ SaveFPRegsMode fp_mode,
+ RememberedSetFinalAction
and_then) {
Label done;
// Load store buffer top.
ExternalReference store_buffer =
@@ -570,13 +598,21 @@
// Call stub on end of buffer.
// Check for end of buffer.
tst(scratch, Operand(StoreBuffer::kStoreBufferOverflowBit));
- b(eq, &done);
+ if (and_then == kFallThroughAtEnd) {
+ b(eq, &done);
+ } else {
+ ASSERT(and_then == kReturnAtEnd);
+ Ret(ne);
+ }
push(lr);
StoreBufferOverflowStub store_buffer_overflow =
StoreBufferOverflowStub(fp_mode);
CallStub(&store_buffer_overflow);
pop(lr);
bind(&done);
+ if (and_then == kReturnAtEnd) {
+ Ret();
+ }
}
@@ -3090,6 +3126,58 @@
tst(scratch, Operand(1 << flag));
b(cc, condition_met);
}
+
+
+void MacroAssembler::IsBlack(Register object,
+ Register scratch0,
+ Register scratch1,
+ Label* is_black) {
+ HasColor(object, scratch0, scratch1, is_black, 1, 0); //
kBlackBitPattern.
+ ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
+}
+
+
+void MacroAssembler::HasColor(Register object,
+ Register bitmap_scratch,
+ Register mask_scratch,
+ Label* has_color,
+ int first_bit,
+ int second_bit) {
+ ASSERT(!Aliasing(object, bitmap_scratch, mask_scratch, no_reg));
+
+ GetMarkBits(object, bitmap_scratch, mask_scratch);
+
+ Label other_color, word_boundary;
+ ldr(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize));
+ tst(ip, Operand(mask_scratch));
+ b(first_bit == 1 ? eq : ne, &other_color);
+ // Shift left 1 by adding.
+ add(mask_scratch, mask_scratch, Operand(mask_scratch), SetCC);
+ b(eq, &word_boundary);
+ tst(ip, Operand(mask_scratch));
+ b(second_bit == 1 ? ne : eq, has_color);
+ jmp(&other_color);
+
+ bind(&word_boundary);
+ ldr(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize +
kPointerSize));
+ tst(ip, Operand(1));
+ b(second_bit == 1 ? ne : eq, has_color);
+ bind(&other_color);
+}
+
+
+void MacroAssembler::GetMarkBits(Register addr_reg,
+ Register bitmap_reg,
+ Register mask_reg) {
+ ASSERT(!Aliasing(addr_reg, bitmap_reg, mask_reg, no_reg));
+ and_(bitmap_reg, addr_reg, Operand(~Page::kPageAlignmentMask));
+ Ubfx(mask_reg, addr_reg, kPointerSizeLog2, Bitmap::kBitsPerCellLog2);
+ const int kLowBits = kPointerSizeLog2 + Bitmap::kBitsPerCellLog2;
+ Ubfx(ip, addr_reg, kLowBits, kPageSizeBits - kLowBits);
+ add(bitmap_reg, bitmap_reg, Operand(ip, LSL, kPointerSizeLog2));
+ mov(ip, Operand(1));
+ mov(mask_reg, Operand(ip, LSL, mask_reg));
+}
void MacroAssembler::ClampUint8(Register output_reg, Register input_reg) {
@@ -3139,6 +3227,17 @@
mov(descriptors, Operand(FACTORY->empty_descriptor_array()));
bind(¬_smi);
}
+
+
+bool Aliasing(Register r1, Register r2, Register r3, Register r4) {
+ if (r1.is(r2)) return true;
+ if (r1.is(r3)) return true;
+ if (r1.is(r4)) return true;
+ if (r2.is(r3)) return true;
+ if (r2.is(r4)) return true;
+ if (r3.is(r4)) return true;
+ return false;
+}
CodePatcher::CodePatcher(byte* address, int instructions)
=======================================
--- /branches/experimental/gc/src/arm/macro-assembler-arm.h Mon Jun 6
04:22:38 2011
+++ /branches/experimental/gc/src/arm/macro-assembler-arm.h Tue Jun 7
02:28:08 2011
@@ -81,6 +81,7 @@
enum RememberedSetAction { EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET };
enum SmiCheck { INLINE_SMI_CHECK, OMIT_SMI_CHECK };
+enum LinkRegisterStatus { kLRHasNotBeenSaved, kLRHasBeenSaved };
bool Aliasing(Register r1, Register r2, Register r3, Register r4);
@@ -164,11 +165,31 @@
Heap::RootListIndex index,
Condition cond = al);
- // Enters the address into the store buffer. RememberedSetHelper only
works
- // if the address is not in new space.
- void RememberedSetHelper(Register address,
+ //
---------------------------------------------------------------------------
+ // GC Support
+
+ void IncrementalMarkingRecordWriteHelper(Register object,
+ Register value,
+ Register address);
+
+ enum RememberedSetFinalAction {
+ kReturnAtEnd,
+ kFallThroughAtEnd
+ };
+
+ // For page containing |object| mark region covering |addr| dirty.
+ // RememberedSetHelper only works if the object is not in new
+ // space.
+ void RememberedSetHelper(Register addr,
Register scratch,
- SaveFPRegsMode save_fp);
+ SaveFPRegsMode save_fp,
+ RememberedSetFinalAction and_then);
+
+ void CheckPageFlag(Register object,
+ Register scratch,
+ MemoryChunk::MemoryChunkFlags flag,
+ Condition cc,
+ Label* condition_met);
// Check if object is in new space.
// scratch can be object itself, but it will be clobbered.
@@ -177,11 +198,40 @@
Condition cond, // eq for new space, ne otherwise.
Label* branch);
- void CheckPageFlag(Register object,
- Register scratch,
- MemoryChunk::MemoryChunkFlags flag,
- Condition cc,
- Label* condition_met);
+ // Check if an object has a given incremental marking color. The color
bits
+ // are found by splitting the address at the bit offset indicated by the
+ // mask: bits that are zero in the mask are used for the address of the
+ // bitmap, and bits that are one in the mask are used for the index of
the
+ // bit.
+ void HasColor(Register object,
+ Register scratch0,
+ Register scratch1,
+ Label* has_color,
+ int first_bit,
+ int second_bit);
+
+ void IsBlack(Register object,
+ Register scratch0,
+ Register scratch1,
+ Label* is_black);
+
+ // Checks the color of an object. If the object is already grey or black
+ // then we just fall through, since it is already live. If it is white
and
+ // we can determine that it doesn't need to be scanned, then we just
mark it
+ // black and fall through. For the rest we jump to the label so the
+ // incremental marker can fix its assumptions.
+ void EnsureNotWhite(Register object,
+ Register scratch1,
+ Register scratch2,
+ Label* object_is_white_and_not_data,
+ Label::Distance distance);
+
+ // Checks whether an object is data-only, ie it does need to be scanned
by the
+ // garbage collector.
+ void IsDataObject(Register value,
+ Register scratch,
+ Label* not_data_object,
+ Label::Distance not_data_object_distance);
// Notify the garbage collector that we wrote a pointer into an object.
// |object| is the object being stored into, |value| is the object being
@@ -195,6 +245,7 @@
int offset,
Register value,
Register scratch,
+ LinkRegisterStatus lr_status,
SaveFPRegsMode save_fp,
RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
SmiCheck smi_check = INLINE_SMI_CHECK);
@@ -206,6 +257,7 @@
int offset,
Register value,
Register scratch,
+ LinkRegisterStatus lr_status,
SaveFPRegsMode save_fp,
RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
SmiCheck smi_check = INLINE_SMI_CHECK) {
@@ -213,6 +265,7 @@
offset + kHeapObjectTag,
value,
scratch,
+ lr_status,
save_fp,
remembered_set_action,
smi_check);
@@ -225,6 +278,7 @@
Register object,
Register address,
Register value,
+ LinkRegisterStatus lr_status,
SaveFPRegsMode save_fp,
RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
SmiCheck smi_check = INLINE_SMI_CHECK);
@@ -1086,6 +1140,13 @@
Register scratch1,
Register scratch2);
+ // Helper for finding the mark bits for an address. Afterwards, the
+ // bitmap register points at the word with the mark bits and the mask
+ // the position of the first bit. Leaves addr_reg unchanged.
+ inline void GetMarkBits(Register addr_reg,
+ Register bitmap_reg,
+ Register mask_reg);
+
// Compute memory operands for safepoint stack slots.
static int SafepointRegisterStackIndex(int reg_code);
MemOperand SafepointRegisterSlot(Register reg);
=======================================
--- /branches/experimental/gc/src/arm/stub-cache-arm.cc Wed May 25 07:05:16
2011
+++ /branches/experimental/gc/src/arm/stub-cache-arm.cc Tue Jun 7 02:28:08
2011
@@ -433,8 +433,12 @@
// Update the write barrier for the array address.
// Pass the now unused name_reg as a scratch register.
__ mov(name_reg, r0);
- __ RecordWriteField(
- receiver_reg, offset, name_reg, scratch, kDontSaveFPRegs);
+ __ RecordWriteField(receiver_reg,
+ offset,
+ name_reg,
+ scratch,
+ kLRHasNotBeenSaved,
+ kDontSaveFPRegs);
} else {
// Write to the properties array.
int offset = index * kPointerSize + FixedArray::kHeaderSize;
@@ -445,8 +449,12 @@
// Update the write barrier for the array address.
// Ok to clobber receiver_reg and name_reg, since we return.
__ mov(name_reg, r0);
- __ RecordWriteField(
- scratch, offset, name_reg, receiver_reg, kDontSaveFPRegs);
+ __ RecordWriteField(scratch,
+ offset,
+ name_reg,
+ receiver_reg,
+ kLRHasNotBeenSaved,
+ kDontSaveFPRegs);
}
// Return the value (register r0).
@@ -1594,6 +1602,7 @@
__ RecordWrite(elements,
end_elements,
r4,
+ kLRHasNotBeenSaved,
kDontSaveFPRegs,
EMIT_REMEMBERED_SET,
OMIT_SMI_CHECK);
@@ -4228,6 +4237,7 @@
__ RecordWrite(elements_reg, // Object.
scratch, // Address.
receiver_reg, // Value.
+ kLRHasNotBeenSaved,
kDontSaveFPRegs);
// value_reg (r0) is preserved.
=======================================
--- /branches/experimental/gc/src/ia32/code-stubs-ia32.cc Mon Jun 6
04:22:38 2011
+++ /branches/experimental/gc/src/ia32/code-stubs-ia32.cc Tue Jun 7
02:28:08 2011
@@ -6318,7 +6318,7 @@
RecordWriteStub::OnNoNeedToInformIncrementalMarker on_no_need) {
Label object_is_black, need_incremental;
- // Let's look at the colour of the object: If it is not black we don't
have
+ // Let's look at the color of the object: If it is not black we don't
have
// to inform the incremental marker.
__ IsBlack(regs_.object(),
regs_.scratch0(),
=======================================
--- /branches/experimental/gc/src/ia32/code-stubs-ia32.h Mon Jun 6
04:22:38 2011
+++ /branches/experimental/gc/src/ia32/code-stubs-ia32.h Tue Jun 7
02:28:08 2011
@@ -525,6 +525,8 @@
Register index_;
LookupMode mode_;
};
+
+
class RecordWriteStub: public CodeStub {
public:
RecordWriteStub(Register object,
=======================================
--- /branches/experimental/gc/src/ia32/macro-assembler-ia32.cc Mon Jun 6
04:22:38 2011
+++ /branches/experimental/gc/src/ia32/macro-assembler-ia32.cc Tue Jun 7
02:28:08 2011
@@ -2294,38 +2294,38 @@
Register scratch1,
Label* is_black,
Label::Distance is_black_near) {
- HasColour(object, scratch0, scratch1,
- is_black, is_black_near,
- 1, 0); // kBlackBitPattern.
+ HasColor(object, scratch0, scratch1,
+ is_black, is_black_near,
+ 1, 0); // kBlackBitPattern.
ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
}
-void MacroAssembler::HasColour(Register object,
- Register bitmap_scratch,
- Register mask_scratch,
- Label* has_colour,
- Label::Distance has_colour_distance,
- int first_bit,
- int second_bit) {
+void MacroAssembler::HasColor(Register object,
+ Register bitmap_scratch,
+ Register mask_scratch,
+ Label* has_color,
+ Label::Distance has_color_distance,
+ int first_bit,
+ int second_bit) {
ASSERT(!Aliasing(object, bitmap_scratch, mask_scratch, ecx));
- MarkBits(object, bitmap_scratch, mask_scratch);
-
- Label other_colour, word_boundary;
+ GetMarkBits(object, bitmap_scratch, mask_scratch);
+
+ Label other_color, word_boundary;
test(mask_scratch, Operand(bitmap_scratch, MemoryChunk::kHeaderSize));
- j(first_bit == 1 ? zero : not_zero, &other_colour, Label::kNear);
+ j(first_bit == 1 ? zero : not_zero, &other_color, Label::kNear);
add(mask_scratch, Operand(mask_scratch)); // Shift left 1 by adding.
j(zero, &word_boundary, Label::kNear);
test(mask_scratch, Operand(bitmap_scratch, MemoryChunk::kHeaderSize));
- j(second_bit == 1 ? not_zero : zero, has_colour, has_colour_distance);
- jmp(&other_colour, Label::kNear);
+ j(second_bit == 1 ? not_zero : zero, has_color, has_color_distance);
+ jmp(&other_color, Label::kNear);
bind(&word_boundary);
test_b(Operand(bitmap_scratch, MemoryChunk::kHeaderSize + kPointerSize),
1);
- j(second_bit == 1 ? not_zero : zero, has_colour, has_colour_distance);
- bind(&other_colour);
+ j(second_bit == 1 ? not_zero : zero, has_color, has_color_distance);
+ bind(&other_color);
}
@@ -2349,9 +2349,9 @@
}
-void MacroAssembler::MarkBits(Register addr_reg,
- Register bitmap_reg,
- Register mask_reg) {
+void MacroAssembler::GetMarkBits(Register addr_reg,
+ Register bitmap_reg,
+ Register mask_reg) {
ASSERT(!Aliasing(addr_reg, bitmap_reg, mask_reg, ecx));
mov(bitmap_reg, Operand(addr_reg));
and_(bitmap_reg, ~Page::kPageAlignmentMask);
@@ -2377,7 +2377,7 @@
Label* value_is_white_and_not_data,
Label::Distance distance) {
ASSERT(!Aliasing(value, bitmap_scratch, mask_scratch, ecx));
- MarkBits(value, bitmap_scratch, mask_scratch);
+ GetMarkBits(value, bitmap_scratch, mask_scratch);
// If the value is black or grey we don't need to do anything.
ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0);
=======================================
--- /branches/experimental/gc/src/ia32/macro-assembler-ia32.h Mon Jun 6
04:22:38 2011
+++ /branches/experimental/gc/src/ia32/macro-assembler-ia32.h Tue Jun 7
02:28:08 2011
@@ -99,18 +99,18 @@
Label* condition_met,
Label::Distance condition_met_distance = Label::kFar);
- // Check if an object has a given incremental marking colour. Also uses
ecx!
- // The colour bits are found by splitting the address at the bit offset
+ // Check if an object has a given incremental marking color. Also uses
ecx!
+ // The color bits are found by splitting the address at the bit offset
// indicated by the mask: bits that are zero in the mask are used for the
// address of the bitmap, and bits that are one in the mask are used for
the
// index of the bit.
- void HasColour(Register object,
- Register scratch0,
- Register scratch1,
- Label* has_colour,
- Label::Distance has_colour_distance,
- int first_bit,
- int second_bit);
+ void HasColor(Register object,
+ Register scratch0,
+ Register scratch1,
+ Label* has_color,
+ Label::Distance has_color_distance,
+ int first_bit,
+ int second_bit);
void IsBlack(Register object,
Register scratch0,
@@ -118,7 +118,7 @@
Label* is_black,
Label::Distance is_black_distance = Label::kFar);
- // Checks the colour of an object. If the object is already grey or
black
+ // Checks the color of an object. If the object is already grey or black
// then we just fall through, since it is already live. If it is white
and
// we can determine that it doesn't need to be scanned, then we just
mark it
// black and fall through. For the rest we jump to the label so the
@@ -788,9 +788,9 @@
// bitmap register points at the word with the mark bits and the mask
// the position of the first bit. Uses ecx as scratch and leaves
addr_reg
// unchanged.
- inline void MarkBits(Register addr_reg,
- Register bitmap_reg,
- Register mask_reg);
+ inline void GetMarkBits(Register addr_reg,
+ Register bitmap_reg,
+ Register mask_reg);
// Compute memory operands for safepoint stack slots.
Operand SafepointRegisterSlot(Register reg);
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
