From 3ef636f7fa32165f33842ce31faf088ef4207ee1 Mon Sep 17 00:00:00 2001 From: "yangguo@chromium.org" Date: Wed, 3 Sep 2014 11:41:54 +0000 Subject: [PATCH] Minor-key-ify remaining code stubs. R=mvstanton@chromium.org Review URL: https://codereview.chromium.org/535733004 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23643 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/arm/code-stubs-arm.cc | 151 ++++++------------------------------------ src/arm/code-stubs-arm.h | 101 ++++++++++++++++------------ src/arm64/code-stubs-arm64.cc | 63 ++++++++---------- src/arm64/code-stubs-arm64.h | 78 ++++++++++++---------- src/code-stubs.h | 2 +- src/ia32/code-stubs-ia32.cc | 48 +++++--------- src/ia32/code-stubs-ia32.h | 87 +++++++++++++----------- src/x64/code-stubs-x64.cc | 42 ++++-------- src/x64/code-stubs-x64.h | 93 ++++++++++++++------------ 9 files changed, 280 insertions(+), 385 deletions(-) diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc index 4224cfe..04d5fe4 100644 --- a/src/arm/code-stubs-arm.cc +++ b/src/arm/code-stubs-arm.cc @@ -142,101 +142,6 @@ void HydrogenCodeStub::GenerateLightweightMiss(MacroAssembler* masm) { } -// Takes a Smi and converts to an IEEE 64 bit floating point value in two -// registers. The format is 1 sign bit, 11 exponent bits (biased 1023) and -// 52 fraction bits (20 in the first word, 32 in the second). Zeros is a -// scratch register. Destroys the source register. No GC occurs during this -// stub so you don't have to set up the frame. -class ConvertToDoubleStub : public PlatformCodeStub { - public: - ConvertToDoubleStub(Isolate* isolate, - Register result_reg_1, - Register result_reg_2, - Register source_reg, - Register scratch_reg) - : PlatformCodeStub(isolate), - result1_(result_reg_1), - result2_(result_reg_2), - source_(source_reg), - zeros_(scratch_reg) { } - - private: - Register result1_; - Register result2_; - Register source_; - Register zeros_; - - // Minor key encoding in 16 bits. - class ModeBits: public BitField {}; - class OpBits: public BitField {}; - - Major MajorKey() const { return ConvertToDouble; } - uint32_t MinorKey() const { - // Encode the parameters in a unique 16 bit value. - return result1_.code() + - (result2_.code() << 4) + - (source_.code() << 8) + - (zeros_.code() << 12); - } - - void Generate(MacroAssembler* masm); -}; - - -void ConvertToDoubleStub::Generate(MacroAssembler* masm) { - Register exponent = result1_; - Register mantissa = result2_; - - Label not_special; - __ SmiUntag(source_); - // Move sign bit from source to destination. This works because the sign bit - // in the exponent word of the double has the same position and polarity as - // the 2's complement sign bit in a Smi. - STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u); - __ and_(exponent, source_, Operand(HeapNumber::kSignMask), SetCC); - // Subtract from 0 if source was negative. - __ rsb(source_, source_, Operand::Zero(), LeaveCC, ne); - - // We have -1, 0 or 1, which we treat specially. Register source_ contains - // absolute value: it is either equal to 1 (special case of -1 and 1), - // greater than 1 (not a special case) or less than 1 (special case of 0). - __ cmp(source_, Operand(1)); - __ b(gt, ¬_special); - - // For 1 or -1 we need to or in the 0 exponent (biased to 1023). - const uint32_t exponent_word_for_1 = - HeapNumber::kExponentBias << HeapNumber::kExponentShift; - __ orr(exponent, exponent, Operand(exponent_word_for_1), LeaveCC, eq); - // 1, 0 and -1 all have 0 for the second word. - __ mov(mantissa, Operand::Zero()); - __ Ret(); - - __ bind(¬_special); - __ clz(zeros_, source_); - // Compute exponent and or it into the exponent register. - // We use mantissa as a scratch register here. Use a fudge factor to - // divide the constant 31 + HeapNumber::kExponentBias, 0x41d, into two parts - // that fit in the ARM's constant field. - int fudge = 0x400; - __ rsb(mantissa, zeros_, Operand(31 + HeapNumber::kExponentBias - fudge)); - __ add(mantissa, mantissa, Operand(fudge)); - __ orr(exponent, - exponent, - Operand(mantissa, LSL, HeapNumber::kExponentShift)); - // Shift up the source chopping the top bit off. - __ add(zeros_, zeros_, Operand(1)); - // This wouldn't work for 1.0 or -1.0 as the shift would be 32 which means 0. - __ mov(source_, Operand(source_, LSL, zeros_)); - // Compute lower part of fraction (last 12 bits). - __ mov(mantissa, Operand(source_, LSL, HeapNumber::kMantissaBitsInTopWord)); - // And the top (top 20 bits). - __ orr(exponent, - exponent, - Operand(source_, LSR, 32 - HeapNumber::kMantissaBitsInTopWord)); - __ Ret(); -} - - void DoubleToIStub::Generate(MacroAssembler* masm) { Label out_of_range, only_low, negate, done; Register input_reg = source(); @@ -358,29 +263,29 @@ void WriteInt32ToHeapNumberStub::Generate(MacroAssembler* masm) { // We test for the special value that has a different exponent. This test // has the neat side effect of setting the flags according to the sign. STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u); - __ cmp(the_int_, Operand(0x80000000u)); + __ cmp(the_int(), Operand(0x80000000u)); __ b(eq, &max_negative_int); // Set up the correct exponent in scratch_. All non-Smi int32s have the same. // A non-Smi integer is 1.xxx * 2^30 so the exponent is 30 (biased). uint32_t non_smi_exponent = (HeapNumber::kExponentBias + 30) << HeapNumber::kExponentShift; - __ mov(scratch_, Operand(non_smi_exponent)); + __ mov(scratch(), Operand(non_smi_exponent)); // Set the sign bit in scratch_ if the value was negative. - __ orr(scratch_, scratch_, Operand(HeapNumber::kSignMask), LeaveCC, cs); + __ orr(scratch(), scratch(), Operand(HeapNumber::kSignMask), LeaveCC, cs); // Subtract from 0 if the value was negative. - __ rsb(the_int_, the_int_, Operand::Zero(), LeaveCC, cs); + __ rsb(the_int(), the_int(), Operand::Zero(), LeaveCC, cs); // We should be masking the implict first digit of the mantissa away here, // but it just ends up combining harmlessly with the last digit of the // exponent that happens to be 1. The sign bit is 0 so we shift 10 to get // the most significant 1 to hit the last bit of the 12 bit sign and exponent. DCHECK(((1 << HeapNumber::kExponentShift) & non_smi_exponent) != 0); const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2; - __ orr(scratch_, scratch_, Operand(the_int_, LSR, shift_distance)); - __ str(scratch_, FieldMemOperand(the_heap_number_, - HeapNumber::kExponentOffset)); - __ mov(scratch_, Operand(the_int_, LSL, 32 - shift_distance)); - __ str(scratch_, FieldMemOperand(the_heap_number_, - HeapNumber::kMantissaOffset)); + __ orr(scratch(), scratch(), Operand(the_int(), LSR, shift_distance)); + __ str(scratch(), + FieldMemOperand(the_heap_number(), HeapNumber::kExponentOffset)); + __ mov(scratch(), Operand(the_int(), LSL, 32 - shift_distance)); + __ str(scratch(), + FieldMemOperand(the_heap_number(), HeapNumber::kMantissaOffset)); __ Ret(); __ bind(&max_negative_int); @@ -390,9 +295,9 @@ void WriteInt32ToHeapNumberStub::Generate(MacroAssembler* masm) { // significant 1 bit is not stored. non_smi_exponent += 1 << HeapNumber::kExponentShift; __ mov(ip, Operand(HeapNumber::kSignMask | non_smi_exponent)); - __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset)); + __ str(ip, FieldMemOperand(the_heap_number(), HeapNumber::kExponentOffset)); __ mov(ip, Operand::Zero()); - __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset)); + __ str(ip, FieldMemOperand(the_heap_number(), HeapNumber::kMantissaOffset)); __ Ret(); } @@ -4004,7 +3909,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { __ cmp(entry_key, Operand(key)); __ b(eq, &in_dictionary); - if (i != kTotalProbes - 1 && mode_ == NEGATIVE_LOOKUP) { + if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) { // Check if the entry name is not a unique name. __ ldr(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset)); __ ldrb(entry_key, @@ -4017,7 +3922,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { // If we are doing negative lookup then probing failure should be // treated as a lookup success. For positive lookup probing failure // should be treated as lookup failure. - if (mode_ == POSITIVE_LOOKUP) { + if (mode() == POSITIVE_LOOKUP) { __ mov(result, Operand::Zero()); __ Ret(); } @@ -4063,11 +3968,8 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { __ b(&skip_to_incremental_compacting); } - if (remembered_set_action_ == EMIT_REMEMBERED_SET) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + if (remembered_set_action() == EMIT_REMEMBERED_SET) { + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } __ Ret(); @@ -4090,7 +3992,7 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { regs_.Save(masm); - if (remembered_set_action_ == EMIT_REMEMBERED_SET) { + if (remembered_set_action() == EMIT_REMEMBERED_SET) { Label dont_need_remembered_set; __ ldr(regs_.scratch0(), MemOperand(regs_.address(), 0)); @@ -4110,10 +4012,7 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { masm, kUpdateRememberedSetOnNoNeedToInformIncrementalMarker, mode); InformIncrementalMarker(masm); regs_.Restore(masm); - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); __ bind(&dont_need_remembered_set); @@ -4128,7 +4027,7 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) { - regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode_); + regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode()); int argument_count = 3; __ PrepareCallCFunction(argument_count, regs_.scratch0()); Register address = @@ -4144,7 +4043,7 @@ void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) { __ CallCFunction( ExternalReference::incremental_marking_record_write_function(isolate()), argument_count); - regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode_); + regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode()); } @@ -4172,10 +4071,7 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( regs_.Restore(masm); if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ Ret(); @@ -4216,10 +4112,7 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( regs_.Restore(masm); if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ Ret(); diff --git a/src/arm/code-stubs-arm.h b/src/arm/code-stubs-arm.h index 06265dd..8a6f8d2 100644 --- a/src/arm/code-stubs-arm.h +++ b/src/arm/code-stubs-arm.h @@ -75,36 +75,39 @@ class StringHelper : public AllStatic { // so you don't have to set up the frame. class WriteInt32ToHeapNumberStub : public PlatformCodeStub { public: - WriteInt32ToHeapNumberStub(Isolate* isolate, - Register the_int, - Register the_heap_number, - Register scratch) - : PlatformCodeStub(isolate), - the_int_(the_int), - the_heap_number_(the_heap_number), - scratch_(scratch) { } + WriteInt32ToHeapNumberStub(Isolate* isolate, Register the_int, + Register the_heap_number, Register scratch) + : PlatformCodeStub(isolate) { + minor_key_ = IntRegisterBits::encode(the_int.code()) | + HeapNumberRegisterBits::encode(the_heap_number.code()) | + ScratchRegisterBits::encode(scratch.code()); + } static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate); private: - Register the_int_; - Register the_heap_number_; - Register scratch_; + Major MajorKey() const { return WriteInt32ToHeapNumber; } + + void Generate(MacroAssembler* masm); + + Register the_int() const { + return Register::from_code(IntRegisterBits::decode(minor_key_)); + } + + Register the_heap_number() const { + return Register::from_code(HeapNumberRegisterBits::decode(minor_key_)); + } + + Register scratch() const { + return Register::from_code(ScratchRegisterBits::decode(minor_key_)); + } // Minor key encoding in 16 bits. class IntRegisterBits: public BitField {}; class HeapNumberRegisterBits: public BitField {}; class ScratchRegisterBits: public BitField {}; - Major MajorKey() const { return WriteInt32ToHeapNumber; } - uint32_t MinorKey() const { - // Encode the parameters in a unique 16 bit value. - return IntRegisterBits::encode(the_int_.code()) - | HeapNumberRegisterBits::encode(the_heap_number_.code()) - | ScratchRegisterBits::encode(scratch_.code()); - } - - void Generate(MacroAssembler* masm); + DISALLOW_COPY_AND_ASSIGN(WriteInt32ToHeapNumberStub); }; @@ -117,14 +120,14 @@ class RecordWriteStub: public PlatformCodeStub { RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode) : PlatformCodeStub(isolate), - object_(object), - value_(value), - address_(address), - remembered_set_action_(remembered_set_action), - save_fp_regs_mode_(fp_mode), regs_(object, // An input reg. address, // An input reg. value) { // One scratch reg. + minor_key_ = ObjectBits::encode(object.code()) | + ValueBits::encode(value.code()) | + AddressBits::encode(address.code()) | + RememberedSetActionBits::encode(remembered_set_action) | + SaveFPRegsModeBits::encode(fp_mode); } enum Mode { @@ -254,6 +257,8 @@ class RecordWriteStub: public PlatformCodeStub { kUpdateRememberedSetOnNoNeedToInformIncrementalMarker }; + Major MajorKey() const { return RecordWrite; } + void Generate(MacroAssembler* masm); void GenerateIncremental(MacroAssembler* masm, Mode mode); void CheckNeedsToInformIncrementalMarker( @@ -262,18 +267,28 @@ class RecordWriteStub: public PlatformCodeStub { Mode mode); void InformIncrementalMarker(MacroAssembler* masm); - Major MajorKey() const { return RecordWrite; } + void Activate(Code* code) { + code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); + } - uint32_t MinorKey() const { - return ObjectBits::encode(object_.code()) | - ValueBits::encode(value_.code()) | - AddressBits::encode(address_.code()) | - RememberedSetActionBits::encode(remembered_set_action_) | - SaveFPRegsModeBits::encode(save_fp_regs_mode_); + Register object() const { + return Register::from_code(ObjectBits::decode(minor_key_)); } - void Activate(Code* code) { - code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); + Register value() const { + return Register::from_code(ValueBits::decode(minor_key_)); + } + + Register address() const { + return Register::from_code(AddressBits::decode(minor_key_)); + } + + RememberedSetAction remembered_set_action() const { + return RememberedSetActionBits::decode(minor_key_); + } + + SaveFPRegsMode save_fp_regs_mode() const { + return SaveFPRegsModeBits::decode(minor_key_); } class ObjectBits: public BitField {}; @@ -282,13 +297,10 @@ class RecordWriteStub: public PlatformCodeStub { class RememberedSetActionBits: public BitField {}; class SaveFPRegsModeBits: public BitField {}; - Register object_; - Register value_; - Register address_; - RememberedSetAction remembered_set_action_; - SaveFPRegsMode save_fp_regs_mode_; Label slow_; RegisterAllocation regs_; + + DISALLOW_COPY_AND_ASSIGN(RecordWriteStub); }; @@ -305,9 +317,10 @@ class DirectCEntryStub: public PlatformCodeStub { private: Major MajorKey() const { return DirectCEntry; } - uint32_t MinorKey() const { return 0; } bool NeedsImmovableCode() { return true; } + + DISALLOW_COPY_AND_ASSIGN(DirectCEntryStub); }; @@ -316,7 +329,9 @@ class NameDictionaryLookupStub: public PlatformCodeStub { enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP }; NameDictionaryLookupStub(Isolate* isolate, LookupMode mode) - : PlatformCodeStub(isolate), mode_(mode) { } + : PlatformCodeStub(isolate) { + minor_key_ = LookupModeBits::encode(mode); + } void Generate(MacroAssembler* masm); @@ -352,11 +367,11 @@ class NameDictionaryLookupStub: public PlatformCodeStub { Major MajorKey() const { return NameDictionaryLookup; } - uint32_t MinorKey() const { return LookupModeBits::encode(mode_); } + LookupMode mode() const { return LookupModeBits::decode(minor_key_); } class LookupModeBits: public BitField {}; - LookupMode mode_; + DISALLOW_COPY_AND_ASSIGN(NameDictionaryLookupStub); }; } } // namespace v8::internal diff --git a/src/arm64/code-stubs-arm64.cc b/src/arm64/code-stubs-arm64.cc index ee22f27..6834bb9 100644 --- a/src/arm64/code-stubs-arm64.cc +++ b/src/arm64/code-stubs-arm64.cc @@ -4031,16 +4031,14 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { // but we need to save them before using them. regs_.Save(masm); - if (remembered_set_action_ == EMIT_REMEMBERED_SET) { + if (remembered_set_action() == EMIT_REMEMBERED_SET) { Label dont_need_remembered_set; - Register value = regs_.scratch0(); - __ Ldr(value, MemOperand(regs_.address())); - __ JumpIfNotInNewSpace(value, &dont_need_remembered_set); + Register val = regs_.scratch0(); + __ Ldr(val, MemOperand(regs_.address())); + __ JumpIfNotInNewSpace(val, &dont_need_remembered_set); - __ CheckPageFlagSet(regs_.object(), - value, - 1 << MemoryChunk::SCAN_ON_SCAVENGE, + __ CheckPageFlagSet(regs_.object(), val, 1 << MemoryChunk::SCAN_ON_SCAVENGE, &dont_need_remembered_set); // First notify the incremental marker if necessary, then update the @@ -4050,11 +4048,9 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { InformIncrementalMarker(masm); regs_.Restore(masm); // Restore the extra scratch registers we used. - __ RememberedSetHelper(object_, - address_, - value_, // scratch1 - save_fp_regs_mode_, - MacroAssembler::kReturnAtEnd); + __ RememberedSetHelper(object(), address(), + value(), // scratch1 + save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); __ Bind(&dont_need_remembered_set); } @@ -4068,7 +4064,7 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) { - regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode_); + regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode()); Register address = x0.Is(regs_.address()) ? regs_.scratch0() : regs_.address(); DCHECK(!address.Is(regs_.object())); @@ -4084,7 +4080,7 @@ void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) { isolate()); __ CallCFunction(function, 3, 0); - regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode_); + regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode()); } @@ -4111,25 +4107,22 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( regs_.Restore(masm); // Restore the extra scratch registers we used. if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) { - __ RememberedSetHelper(object_, - address_, - value_, // scratch1 - save_fp_regs_mode_, - MacroAssembler::kReturnAtEnd); + __ RememberedSetHelper(object(), address(), + value(), // scratch1 + save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ Ret(); } __ Bind(&on_black); // Get the value from the slot. - Register value = regs_.scratch0(); - __ Ldr(value, MemOperand(regs_.address())); + Register val = regs_.scratch0(); + __ Ldr(val, MemOperand(regs_.address())); if (mode == INCREMENTAL_COMPACTION) { Label ensure_not_white; - __ CheckPageFlagClear(value, - regs_.scratch1(), + __ CheckPageFlagClear(val, regs_.scratch1(), MemoryChunk::kEvacuationCandidateMask, &ensure_not_white); @@ -4144,7 +4137,7 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( // We need extra registers for this, so we push the object and the address // register temporarily. __ Push(regs_.address(), regs_.object()); - __ EnsureNotWhite(value, + __ EnsureNotWhite(val, regs_.scratch1(), // Scratch. regs_.object(), // Scratch. regs_.address(), // Scratch. @@ -4154,11 +4147,9 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( regs_.Restore(masm); // Restore the extra scratch registers we used. if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) { - __ RememberedSetHelper(object_, - address_, - value_, // scratch1 - save_fp_regs_mode_, - MacroAssembler::kReturnAtEnd); + __ RememberedSetHelper(object(), address(), + value(), // scratch1 + save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ Ret(); } @@ -4186,12 +4177,10 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { __ adr(xzr, &skip_to_incremental_compacting); } - if (remembered_set_action_ == EMIT_REMEMBERED_SET) { - __ RememberedSetHelper(object_, - address_, - value_, // scratch1 - save_fp_regs_mode_, - MacroAssembler::kReturnAtEnd); + if (remembered_set_action() == EMIT_REMEMBERED_SET) { + __ RememberedSetHelper(object(), address(), + value(), // scratch1 + save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } __ Ret(); @@ -4626,7 +4615,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { __ Cmp(entry_key, key); __ B(eq, &in_dictionary); - if (i != kTotalProbes - 1 && mode_ == NEGATIVE_LOOKUP) { + if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) { // Check if the entry name is not a unique name. __ Ldr(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset)); __ Ldrb(entry_key, FieldMemOperand(entry_key, Map::kInstanceTypeOffset)); @@ -4638,7 +4627,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { // If we are doing negative lookup then probing failure should be // treated as a lookup success. For positive lookup, probing failure // should be treated as lookup failure. - if (mode_ == POSITIVE_LOOKUP) { + if (mode() == POSITIVE_LOOKUP) { __ Mov(result, 0); __ Ret(); } diff --git a/src/arm64/code-stubs-arm64.h b/src/arm64/code-stubs-arm64.h index 456b2bf..3297ab1 100644 --- a/src/arm64/code-stubs-arm64.h +++ b/src/arm64/code-stubs-arm64.h @@ -59,12 +59,15 @@ class StoreRegistersStateStub: public PlatformCodeStub { : PlatformCodeStub(isolate) {} static Register to_be_pushed_lr() { return ip0; } + static void GenerateAheadOfTime(Isolate* isolate); + private: Major MajorKey() const { return StoreRegistersState; } - uint32_t MinorKey() const { return 0; } void Generate(MacroAssembler* masm); + + DISALLOW_COPY_AND_ASSIGN(StoreRegistersStateStub); }; @@ -76,9 +79,10 @@ class RestoreRegistersStateStub: public PlatformCodeStub { static void GenerateAheadOfTime(Isolate* isolate); private: Major MajorKey() const { return RestoreRegistersState; } - uint32_t MinorKey() const { return 0; } void Generate(MacroAssembler* masm); + + DISALLOW_COPY_AND_ASSIGN(RestoreRegistersStateStub); }; @@ -94,14 +98,17 @@ class RecordWriteStub: public PlatformCodeStub { RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode) : PlatformCodeStub(isolate), - object_(object), - value_(value), - address_(address), - remembered_set_action_(remembered_set_action), - save_fp_regs_mode_(fp_mode), regs_(object, // An input reg. address, // An input reg. value) { // One scratch reg. + DCHECK(object.Is64Bits()); + DCHECK(value.Is64Bits()); + DCHECK(address.Is64Bits()); + minor_key_ = ObjectBits::encode(object.code()) | + ValueBits::encode(value.code()) | + AddressBits::encode(address.code()) | + RememberedSetActionBits::encode(remembered_set_action) | + SaveFPRegsModeBits::encode(fp_mode); } enum Mode { @@ -281,47 +288,43 @@ class RecordWriteStub: public PlatformCodeStub { friend class RecordWriteStub; }; - // A list of stub variants which are pregenerated. - // The variants are stored in the same format as the minor key, so - // MinorKeyFor() can be used to populate and check this list. - static const int kAheadOfTime[]; - - void Generate(MacroAssembler* masm); - void GenerateIncremental(MacroAssembler* masm, Mode mode); - enum OnNoNeedToInformIncrementalMarker { kReturnOnNoNeedToInformIncrementalMarker, kUpdateRememberedSetOnNoNeedToInformIncrementalMarker }; + Major MajorKey() const { return RecordWrite; } + + void Generate(MacroAssembler* masm); + void GenerateIncremental(MacroAssembler* masm, Mode mode); void CheckNeedsToInformIncrementalMarker( MacroAssembler* masm, OnNoNeedToInformIncrementalMarker on_no_need, Mode mode); void InformIncrementalMarker(MacroAssembler* masm); - Major MajorKey() const { return RecordWrite; } + void Activate(Code* code) { + code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); + } - uint32_t MinorKey() const { - return MinorKeyFor(object_, value_, address_, remembered_set_action_, - save_fp_regs_mode_); + Register object() const { + return Register::from_code(ObjectBits::decode(minor_key_)); } - static uint32_t MinorKeyFor(Register object, Register value, Register address, - RememberedSetAction action, - SaveFPRegsMode fp_mode) { - DCHECK(object.Is64Bits()); - DCHECK(value.Is64Bits()); - DCHECK(address.Is64Bits()); - return ObjectBits::encode(object.code()) | - ValueBits::encode(value.code()) | - AddressBits::encode(address.code()) | - RememberedSetActionBits::encode(action) | - SaveFPRegsModeBits::encode(fp_mode); + Register value() const { + return Register::from_code(ValueBits::decode(minor_key_)); } - void Activate(Code* code) { - code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); + Register address() const { + return Register::from_code(AddressBits::decode(minor_key_)); + } + + RememberedSetAction remembered_set_action() const { + return RememberedSetActionBits::decode(minor_key_); + } + + SaveFPRegsMode save_fp_regs_mode() const { + return SaveFPRegsModeBits::decode(minor_key_); } class ObjectBits: public BitField {}; @@ -350,9 +353,10 @@ class DirectCEntryStub: public PlatformCodeStub { private: Major MajorKey() const { return DirectCEntry; } - uint32_t MinorKey() const { return 0; } bool NeedsImmovableCode() { return true; } + + DISALLOW_COPY_AND_ASSIGN(DirectCEntryStub); }; @@ -361,7 +365,9 @@ class NameDictionaryLookupStub: public PlatformCodeStub { enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP }; NameDictionaryLookupStub(Isolate* isolate, LookupMode mode) - : PlatformCodeStub(isolate), mode_(mode) { } + : PlatformCodeStub(isolate) { + minor_key_ = LookupModeBits::encode(mode); + } void Generate(MacroAssembler* masm); @@ -397,11 +403,11 @@ class NameDictionaryLookupStub: public PlatformCodeStub { Major MajorKey() const { return NameDictionaryLookup; } - uint32_t MinorKey() const { return LookupModeBits::encode(mode_); } + LookupMode mode() const { return LookupModeBits::decode(minor_key_); } class LookupModeBits: public BitField {}; - LookupMode mode_; + DISALLOW_COPY_AND_ASSIGN(NameDictionaryLookupStub); }; } } // namespace v8::internal diff --git a/src/code-stubs.h b/src/code-stubs.h index b6ac808..212ea7b 100644 --- a/src/code-stubs.h +++ b/src/code-stubs.h @@ -187,7 +187,7 @@ class CodeStub BASE_EMBEDDED { // Returns information for computing the number key. virtual Major MajorKey() const = 0; - virtual uint32_t MinorKey() const { return minor_key_; } + uint32_t MinorKey() const { return minor_key_; } virtual InlineCacheState GetICState() const { return UNINITIALIZED; } virtual ExtraICState GetExtraICState() const { return kNoExtraICState; } diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc index 35caa3e..9d7c186 100644 --- a/src/ia32/code-stubs-ia32.cc +++ b/src/ia32/code-stubs-ia32.cc @@ -3870,9 +3870,9 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { Label in_dictionary, maybe_in_dictionary, not_in_dictionary; - Register scratch = result_; + Register scratch = result(); - __ mov(scratch, FieldOperand(dictionary_, kCapacityOffset)); + __ mov(scratch, FieldOperand(dictionary(), kCapacityOffset)); __ dec(scratch); __ SmiUntag(scratch); __ push(scratch); @@ -3892,13 +3892,11 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { // Scale the index by multiplying by the entry size. DCHECK(NameDictionary::kEntrySize == 3); - __ lea(index_, Operand(scratch, scratch, times_2, 0)); // index *= 3. + __ lea(index(), Operand(scratch, scratch, times_2, 0)); // index *= 3. // Having undefined at this place means the name is not contained. DCHECK_EQ(kSmiTagSize, 1); - __ mov(scratch, Operand(dictionary_, - index_, - times_pointer_size, + __ mov(scratch, Operand(dictionary(), index(), times_pointer_size, kElementsStartOffset - kHeapObjectTag)); __ cmp(scratch, isolate()->factory()->undefined_value()); __ j(equal, ¬_in_dictionary); @@ -3907,7 +3905,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { __ cmp(scratch, Operand(esp, 3 * kPointerSize)); __ j(equal, &in_dictionary); - if (i != kTotalProbes - 1 && mode_ == NEGATIVE_LOOKUP) { + if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) { // If we hit a key that is not a unique name during negative // lookup we have to bailout as this key might be equal to the // key we are looking for. @@ -3923,19 +3921,19 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { // If we are doing negative lookup then probing failure should be // treated as a lookup success. For positive lookup probing failure // should be treated as lookup failure. - if (mode_ == POSITIVE_LOOKUP) { - __ mov(result_, Immediate(0)); + if (mode() == POSITIVE_LOOKUP) { + __ mov(result(), Immediate(0)); __ Drop(1); __ ret(2 * kPointerSize); } __ bind(&in_dictionary); - __ mov(result_, Immediate(1)); + __ mov(result(), Immediate(1)); __ Drop(1); __ ret(2 * kPointerSize); __ bind(¬_in_dictionary); - __ mov(result_, Immediate(0)); + __ mov(result(), Immediate(0)); __ Drop(1); __ ret(2 * kPointerSize); } @@ -3965,11 +3963,8 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { __ jmp(&skip_to_incremental_noncompacting, Label::kNear); __ jmp(&skip_to_incremental_compacting, Label::kFar); - if (remembered_set_action_ == EMIT_REMEMBERED_SET) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + if (remembered_set_action() == EMIT_REMEMBERED_SET) { + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ ret(0); @@ -3991,7 +3986,7 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { regs_.Save(masm); - if (remembered_set_action_ == EMIT_REMEMBERED_SET) { + if (remembered_set_action() == EMIT_REMEMBERED_SET) { Label dont_need_remembered_set; __ mov(regs_.scratch0(), Operand(regs_.address(), 0)); @@ -4013,10 +4008,7 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { mode); InformIncrementalMarker(masm); regs_.Restore(masm); - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); __ bind(&dont_need_remembered_set); @@ -4033,7 +4025,7 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) { - regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode_); + regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode()); int argument_count = 3; __ PrepareCallCFunction(argument_count, regs_.scratch0()); __ mov(Operand(esp, 0 * kPointerSize), regs_.object()); @@ -4046,7 +4038,7 @@ void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) { ExternalReference::incremental_marking_record_write_function(isolate()), argument_count); - regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode_); + regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode()); } @@ -4077,10 +4069,7 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( regs_.Restore(masm); if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ ret(0); @@ -4125,10 +4114,7 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( regs_.Restore(masm); if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ ret(0); diff --git a/src/ia32/code-stubs-ia32.h b/src/ia32/code-stubs-ia32.h index bc08cb0..1e5c6cc 100644 --- a/src/ia32/code-stubs-ia32.h +++ b/src/ia32/code-stubs-ia32.h @@ -75,13 +75,13 @@ class NameDictionaryLookupStub: public PlatformCodeStub { public: enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP }; - NameDictionaryLookupStub(Isolate* isolate, - Register dictionary, - Register result, - Register index, - LookupMode mode) - : PlatformCodeStub(isolate), - dictionary_(dictionary), result_(result), index_(index), mode_(mode) { } + NameDictionaryLookupStub(Isolate* isolate, Register dictionary, + Register result, Register index, LookupMode mode) + : PlatformCodeStub(isolate) { + minor_key_ = DictionaryBits::encode(dictionary.code()) | + ResultBits::encode(result.code()) | + IndexBits::encode(index.code()) | LookupModeBits::encode(mode); + } void Generate(MacroAssembler* masm); @@ -116,22 +116,26 @@ class NameDictionaryLookupStub: public PlatformCodeStub { Major MajorKey() const { return NameDictionaryLookup; } - uint32_t MinorKey() const { - return DictionaryBits::encode(dictionary_.code()) | - ResultBits::encode(result_.code()) | - IndexBits::encode(index_.code()) | - LookupModeBits::encode(mode_); + Register dictionary() const { + return Register::from_code(DictionaryBits::decode(minor_key_)); + } + + Register result() const { + return Register::from_code(ResultBits::decode(minor_key_)); } + Register index() const { + return Register::from_code(IndexBits::decode(minor_key_)); + } + + LookupMode mode() const { return LookupModeBits::decode(minor_key_); } + class DictionaryBits: public BitField {}; class ResultBits: public BitField {}; class IndexBits: public BitField {}; class LookupModeBits: public BitField {}; - Register dictionary_; - Register result_; - Register index_; - LookupMode mode_; + DISALLOW_COPY_AND_ASSIGN(NameDictionaryLookupStub); }; @@ -144,14 +148,14 @@ class RecordWriteStub: public PlatformCodeStub { RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode) : PlatformCodeStub(isolate), - object_(object), - value_(value), - address_(address), - remembered_set_action_(remembered_set_action), - save_fp_regs_mode_(fp_mode), regs_(object, // An input reg. address, // An input reg. value) { // One scratch reg. + minor_key_ = ObjectBits::encode(object.code()) | + ValueBits::encode(value.code()) | + AddressBits::encode(address.code()) | + RememberedSetActionBits::encode(remembered_set_action) | + SaveFPRegsModeBits::encode(fp_mode); } enum Mode { @@ -353,8 +357,10 @@ class RecordWriteStub: public PlatformCodeStub { enum OnNoNeedToInformIncrementalMarker { kReturnOnNoNeedToInformIncrementalMarker, kUpdateRememberedSetOnNoNeedToInformIncrementalMarker - } -; + }; + + Major MajorKey() const { return RecordWrite; } + void Generate(MacroAssembler* masm); void GenerateIncremental(MacroAssembler* masm, Mode mode); void CheckNeedsToInformIncrementalMarker( @@ -363,18 +369,28 @@ class RecordWriteStub: public PlatformCodeStub { Mode mode); void InformIncrementalMarker(MacroAssembler* masm); - Major MajorKey() const { return RecordWrite; } + void Activate(Code* code) { + code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); + } - uint32_t MinorKey() const { - return ObjectBits::encode(object_.code()) | - ValueBits::encode(value_.code()) | - AddressBits::encode(address_.code()) | - RememberedSetActionBits::encode(remembered_set_action_) | - SaveFPRegsModeBits::encode(save_fp_regs_mode_); + Register object() const { + return Register::from_code(ObjectBits::decode(minor_key_)); } - void Activate(Code* code) { - code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); + Register value() const { + return Register::from_code(ValueBits::decode(minor_key_)); + } + + Register address() const { + return Register::from_code(AddressBits::decode(minor_key_)); + } + + RememberedSetAction remembered_set_action() const { + return RememberedSetActionBits::decode(minor_key_); + } + + SaveFPRegsMode save_fp_regs_mode() const { + return SaveFPRegsModeBits::decode(minor_key_); } class ObjectBits: public BitField {}; @@ -383,12 +399,9 @@ class RecordWriteStub: public PlatformCodeStub { class RememberedSetActionBits: public BitField {}; class SaveFPRegsModeBits: public BitField {}; - Register object_; - Register value_; - Register address_; - RememberedSetAction remembered_set_action_; - SaveFPRegsMode save_fp_regs_mode_; RegisterAllocation regs_; + + DISALLOW_COPY_AND_ASSIGN(RecordWriteStub); }; diff --git a/src/x64/code-stubs-x64.cc b/src/x64/code-stubs-x64.cc index 12f53b1..cad45c6 100644 --- a/src/x64/code-stubs-x64.cc +++ b/src/x64/code-stubs-x64.cc @@ -3803,9 +3803,9 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { Label in_dictionary, maybe_in_dictionary, not_in_dictionary; - Register scratch = result_; + Register scratch = result(); - __ SmiToInteger32(scratch, FieldOperand(dictionary_, kCapacityOffset)); + __ SmiToInteger32(scratch, FieldOperand(dictionary(), kCapacityOffset)); __ decl(scratch); __ Push(scratch); @@ -3826,12 +3826,10 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { // Scale the index by multiplying by the entry size. DCHECK(NameDictionary::kEntrySize == 3); - __ leap(index_, Operand(scratch, scratch, times_2, 0)); // index *= 3. + __ leap(index(), Operand(scratch, scratch, times_2, 0)); // index *= 3. // Having undefined at this place means the name is not contained. - __ movp(scratch, Operand(dictionary_, - index_, - times_pointer_size, + __ movp(scratch, Operand(dictionary(), index(), times_pointer_size, kElementsStartOffset - kHeapObjectTag)); __ Cmp(scratch, isolate()->factory()->undefined_value()); @@ -3841,7 +3839,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { __ cmpp(scratch, args.GetArgumentOperand(0)); __ j(equal, &in_dictionary); - if (i != kTotalProbes - 1 && mode_ == NEGATIVE_LOOKUP) { + if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) { // If we hit a key that is not a unique name during negative // lookup we have to bailout as this key might be equal to the // key we are looking for. @@ -3857,7 +3855,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { // If we are doing negative lookup then probing failure should be // treated as a lookup success. For positive lookup probing failure // should be treated as lookup failure. - if (mode_ == POSITIVE_LOOKUP) { + if (mode() == POSITIVE_LOOKUP) { __ movp(scratch, Immediate(0)); __ Drop(1); __ ret(2 * kPointerSize); @@ -3900,11 +3898,8 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { __ jmp(&skip_to_incremental_noncompacting, Label::kNear); __ jmp(&skip_to_incremental_compacting, Label::kFar); - if (remembered_set_action_ == EMIT_REMEMBERED_SET) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + if (remembered_set_action() == EMIT_REMEMBERED_SET) { + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ ret(0); @@ -3926,7 +3921,7 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { regs_.Save(masm); - if (remembered_set_action_ == EMIT_REMEMBERED_SET) { + if (remembered_set_action() == EMIT_REMEMBERED_SET) { Label dont_need_remembered_set; __ movp(regs_.scratch0(), Operand(regs_.address(), 0)); @@ -3946,10 +3941,7 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { masm, kUpdateRememberedSetOnNoNeedToInformIncrementalMarker, mode); InformIncrementalMarker(masm); regs_.Restore(masm); - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); __ bind(&dont_need_remembered_set); @@ -3964,7 +3956,7 @@ void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) { void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) { - regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode_); + regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode()); Register address = arg_reg_1.is(regs_.address()) ? kScratchRegister : regs_.address(); DCHECK(!address.is(regs_.object())); @@ -3982,7 +3974,7 @@ void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) { __ CallCFunction( ExternalReference::incremental_marking_record_write_function(isolate()), argument_count); - regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode_); + regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode()); } @@ -4015,10 +4007,7 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( regs_.Restore(masm); if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ ret(0); @@ -4060,10 +4049,7 @@ void RecordWriteStub::CheckNeedsToInformIncrementalMarker( regs_.Restore(masm); if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) { - __ RememberedSetHelper(object_, - address_, - value_, - save_fp_regs_mode_, + __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(), MacroAssembler::kReturnAtEnd); } else { __ ret(0); diff --git a/src/x64/code-stubs-x64.h b/src/x64/code-stubs-x64.h index d4f6be1..bcbf220 100644 --- a/src/x64/code-stubs-x64.h +++ b/src/x64/code-stubs-x64.h @@ -71,16 +71,13 @@ class NameDictionaryLookupStub: public PlatformCodeStub { public: enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP }; - NameDictionaryLookupStub(Isolate* isolate, - Register dictionary, - Register result, - Register index, - LookupMode mode) - : PlatformCodeStub(isolate), - dictionary_(dictionary), - result_(result), - index_(index), - mode_(mode) { } + NameDictionaryLookupStub(Isolate* isolate, Register dictionary, + Register result, Register index, LookupMode mode) + : PlatformCodeStub(isolate) { + minor_key_ = DictionaryBits::encode(dictionary.code()) | + ResultBits::encode(result.code()) | + IndexBits::encode(index.code()) | LookupModeBits::encode(mode); + } void Generate(MacroAssembler* masm); @@ -115,42 +112,43 @@ class NameDictionaryLookupStub: public PlatformCodeStub { Major MajorKey() const { return NameDictionaryLookup; } - uint32_t MinorKey() const { - return DictionaryBits::encode(dictionary_.code()) | - ResultBits::encode(result_.code()) | - IndexBits::encode(index_.code()) | - LookupModeBits::encode(mode_); + Register dictionary() const { + return Register::from_code(DictionaryBits::decode(minor_key_)); + } + + Register result() const { + return Register::from_code(ResultBits::decode(minor_key_)); + } + + Register index() const { + return Register::from_code(IndexBits::decode(minor_key_)); } + LookupMode mode() const { return LookupModeBits::decode(minor_key_); } + class DictionaryBits: public BitField {}; class ResultBits: public BitField {}; class IndexBits: public BitField {}; class LookupModeBits: public BitField {}; - Register dictionary_; - Register result_; - Register index_; - LookupMode mode_; + DISALLOW_COPY_AND_ASSIGN(NameDictionaryLookupStub); }; class RecordWriteStub: public PlatformCodeStub { public: - RecordWriteStub(Isolate* isolate, - Register object, - Register value, - Register address, - RememberedSetAction remembered_set_action, + RecordWriteStub(Isolate* isolate, Register object, Register value, + Register address, RememberedSetAction remembered_set_action, SaveFPRegsMode fp_mode) : PlatformCodeStub(isolate), - object_(object), - value_(value), - address_(address), - remembered_set_action_(remembered_set_action), - save_fp_regs_mode_(fp_mode), regs_(object, // An input reg. address, // An input reg. value) { // One scratch reg. + minor_key_ = ObjectBits::encode(object.code()) | + ValueBits::encode(value.code()) | + AddressBits::encode(address.code()) | + RememberedSetActionBits::encode(remembered_set_action) | + SaveFPRegsModeBits::encode(fp_mode); } enum Mode { @@ -336,6 +334,8 @@ class RecordWriteStub: public PlatformCodeStub { kUpdateRememberedSetOnNoNeedToInformIncrementalMarker }; + Major MajorKey() const { return RecordWrite; } + void Generate(MacroAssembler* masm); void GenerateIncremental(MacroAssembler* masm, Mode mode); void CheckNeedsToInformIncrementalMarker( @@ -344,18 +344,28 @@ class RecordWriteStub: public PlatformCodeStub { Mode mode); void InformIncrementalMarker(MacroAssembler* masm); - Major MajorKey() const { return RecordWrite; } + void Activate(Code* code) { + code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); + } - uint32_t MinorKey() const { - return ObjectBits::encode(object_.code()) | - ValueBits::encode(value_.code()) | - AddressBits::encode(address_.code()) | - RememberedSetActionBits::encode(remembered_set_action_) | - SaveFPRegsModeBits::encode(save_fp_regs_mode_); + Register object() const { + return Register::from_code(ObjectBits::decode(minor_key_)); } - void Activate(Code* code) { - code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); + Register value() const { + return Register::from_code(ValueBits::decode(minor_key_)); + } + + Register address() const { + return Register::from_code(AddressBits::decode(minor_key_)); + } + + RememberedSetAction remembered_set_action() const { + return RememberedSetActionBits::decode(minor_key_); + } + + SaveFPRegsMode save_fp_regs_mode() const { + return SaveFPRegsModeBits::decode(minor_key_); } class ObjectBits: public BitField {}; @@ -364,13 +374,10 @@ class RecordWriteStub: public PlatformCodeStub { class RememberedSetActionBits: public BitField {}; class SaveFPRegsModeBits: public BitField {}; - Register object_; - Register value_; - Register address_; - RememberedSetAction remembered_set_action_; - SaveFPRegsMode save_fp_regs_mode_; Label slow_; RegisterAllocation regs_; + + DISALLOW_COPY_AND_ASSIGN(RecordWriteStub); }; -- 2.7.4