diff --git a/src/mips/code-stubs-mips.cc b/src/mips/code-stubs-mips.cc index a333dcbc29..0c9f0b0f1a 100644 --- a/src/mips/code-stubs-mips.cc +++ b/src/mips/code-stubs-mips.cc @@ -145,108 +145,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, mantissa; - if (kArchEndian == kLittle) { - exponent = result1_; - mantissa = result2_; - } else { - exponent = result2_; - mantissa = result1_; - } - Label not_special; - // Convert from Smi to integer. - __ sra(source_, source_, kSmiTagSize); - // 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)); - // Subtract from 0 if source was negative. - __ subu(at, zero_reg, source_); - __ Movn(source_, at, exponent); - - // 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). - __ Branch(¬_special, gt, source_, Operand(1)); - - // 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; - // Safe to use 'at' as dest reg here. - __ Or(at, exponent, Operand(exponent_word_for_1)); - __ Movn(exponent, at, source_); // Write exp when source not 0. - // 1, 0 and -1 all have 0 for the second word. - __ Ret(USE_DELAY_SLOT); - __ mov(mantissa, zero_reg); - - __ bind(¬_special); - // Count leading zeros. - // Gets the wrong answer for 0, but we already checked for that case above. - __ Clz(zeros_, source_); - // Compute exponent and or it into the exponent register. - // We use mantissa as a scratch register here. - __ li(mantissa, Operand(31 + HeapNumber::kExponentBias)); - __ subu(mantissa, mantissa, zeros_); - __ sll(mantissa, mantissa, HeapNumber::kExponentShift); - __ Or(exponent, exponent, mantissa); - - // Shift up the source chopping the top bit off. - __ Addu(zeros_, zeros_, Operand(1)); - // This wouldn't work for 1.0 or -1.0 as the shift would be 32 which means 0. - __ sllv(source_, source_, zeros_); - // Compute lower part of fraction (last 12 bits). - __ sll(mantissa, source_, HeapNumber::kMantissaBitsInTopWord); - // And the top (top 20 bits). - __ srl(source_, source_, 32 - HeapNumber::kMantissaBitsInTopWord); - - __ Ret(USE_DELAY_SLOT); - __ or_(exponent, exponent, source_); -} - - void DoubleToIStub::Generate(MacroAssembler* masm) { Label out_of_range, only_low, negate, done; Register input_reg = source(); @@ -403,32 +301,32 @@ void WriteInt32ToHeapNumberStub::Generate(MacroAssembler* masm) { // We test for the special value that has a different exponent. STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u); // Test sign, and save for later conditionals. - __ And(sign_, the_int_, Operand(0x80000000u)); - __ Branch(&max_negative_int, eq, the_int_, Operand(0x80000000u)); + __ And(sign(), the_int(), Operand(0x80000000u)); + __ Branch(&max_negative_int, eq, the_int(), Operand(0x80000000u)); // 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; - __ li(scratch_, Operand(non_smi_exponent)); + __ li(scratch(), Operand(non_smi_exponent)); // Set the sign bit in scratch_ if the value was negative. - __ or_(scratch_, scratch_, sign_); + __ or_(scratch(), scratch(), sign()); // Subtract from 0 if the value was negative. - __ subu(at, zero_reg, the_int_); - __ Movn(the_int_, at, sign_); + __ subu(at, zero_reg, the_int()); + __ Movn(the_int(), at, sign()); // 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; - __ srl(at, the_int_, shift_distance); - __ or_(scratch_, scratch_, at); - __ sw(scratch_, FieldMemOperand(the_heap_number_, + __ srl(at, the_int(), shift_distance); + __ or_(scratch(), scratch(), at); + __ sw(scratch(), FieldMemOperand(the_heap_number(), HeapNumber::kExponentOffset)); - __ sll(scratch_, the_int_, 32 - shift_distance); + __ sll(scratch(), the_int(), 32 - shift_distance); __ Ret(USE_DELAY_SLOT); - __ sw(scratch_, FieldMemOperand(the_heap_number_, + __ sw(scratch(), FieldMemOperand(the_heap_number(), HeapNumber::kMantissaOffset)); __ bind(&max_negative_int); @@ -437,13 +335,13 @@ void WriteInt32ToHeapNumberStub::Generate(MacroAssembler* masm) { // The actual mantissa bits stored are all 0 because the implicit most // significant 1 bit is not stored. non_smi_exponent += 1 << HeapNumber::kExponentShift; - __ li(scratch_, Operand(HeapNumber::kSignMask | non_smi_exponent)); - __ sw(scratch_, - FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset)); - __ mov(scratch_, zero_reg); + __ li(scratch(), Operand(HeapNumber::kSignMask | non_smi_exponent)); + __ sw(scratch(), + FieldMemOperand(the_heap_number(), HeapNumber::kExponentOffset)); + __ mov(scratch(), zero_reg); __ Ret(USE_DELAY_SLOT); - __ sw(scratch_, - FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset)); + __ sw(scratch(), + FieldMemOperand(the_heap_number(), HeapNumber::kMantissaOffset)); } @@ -4228,7 +4126,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { // Stop if found the property. __ Branch(&in_dictionary, eq, entry_key, Operand(key)); - if (i != kTotalProbes - 1 && mode_ == NEGATIVE_LOOKUP) { + if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) { // Check if the entry name is not a unique name. __ lw(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset)); __ lbu(entry_key, @@ -4241,7 +4139,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) { __ Ret(USE_DELAY_SLOT); __ mov(result, zero_reg); } @@ -4285,11 +4183,11 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { __ beq(zero_reg, zero_reg, &skip_to_incremental_compacting); __ nop(); - 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(); @@ -4311,7 +4209,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; __ lw(regs_.scratch0(), MemOperand(regs_.address(), 0)); @@ -4331,10 +4229,10 @@ 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); @@ -4349,7 +4247,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 = @@ -4365,7 +4263,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()); } @@ -4393,10 +4291,10 @@ 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(); @@ -4437,10 +4335,10 @@ 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/mips/code-stubs-mips.h b/src/mips/code-stubs-mips.h index 4a3833d2aa..acc9c6075d 100644 --- a/src/mips/code-stubs-mips.h +++ b/src/mips/code-stubs-mips.h @@ -104,29 +104,42 @@ class RestoreRegistersStateStub: public PlatformCodeStub { // 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, + WriteInt32ToHeapNumberStub(Isolate* isolate, Register the_int, + Register the_heap_number, Register scratch, Register scratch2) - : PlatformCodeStub(isolate), - the_int_(the_int), - the_heap_number_(the_heap_number), - scratch_(scratch), - sign_(scratch2) { - DCHECK(IntRegisterBits::is_valid(the_int_.code())); - DCHECK(HeapNumberRegisterBits::is_valid(the_heap_number_.code())); - DCHECK(ScratchRegisterBits::is_valid(scratch_.code())); - DCHECK(SignRegisterBits::is_valid(sign_.code())); + : PlatformCodeStub(isolate) { + minor_key_ = IntRegisterBits::encode(the_int.code()) | + HeapNumberRegisterBits::encode(the_heap_number.code()) | + ScratchRegisterBits::encode(scratch.code()) | + SignRegisterBits::encode(scratch2.code()); + DCHECK(IntRegisterBits::is_valid(the_int.code())); + DCHECK(HeapNumberRegisterBits::is_valid(the_heap_number.code())); + DCHECK(ScratchRegisterBits::is_valid(scratch.code())); + DCHECK(SignRegisterBits::is_valid(scratch2.code())); } static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate); private: - Register the_int_; - Register the_heap_number_; - Register scratch_; - Register sign_; + 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_)); + } + + Register sign() const { + return Register::from_code(SignRegisterBits::decode(minor_key_)); + } // Minor key encoding in 16 bits. class IntRegisterBits: public BitField {}; @@ -134,16 +147,7 @@ class WriteInt32ToHeapNumberStub : public PlatformCodeStub { class ScratchRegisterBits: public BitField {}; class SignRegisterBits: 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()) - | SignRegisterBits::encode(sign_.code()); - } - - void Generate(MacroAssembler* masm); + DISALLOW_COPY_AND_ASSIGN(WriteInt32ToHeapNumberStub); }; @@ -156,14 +160,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 { @@ -297,6 +301,8 @@ class RecordWriteStub: public PlatformCodeStub { kUpdateRememberedSetOnNoNeedToInformIncrementalMarker }; + Major MajorKey() const { return RecordWrite; } + void Generate(MacroAssembler* masm); void GenerateIncremental(MacroAssembler* masm, Mode mode); void CheckNeedsToInformIncrementalMarker( @@ -305,33 +311,40 @@ class RecordWriteStub: public PlatformCodeStub { Mode mode); void InformIncrementalMarker(MacroAssembler* masm); - Major MajorKey() const { return RecordWrite; } - - 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_); - } - void Activate(Code* code) { code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); } + Register object() const { + return Register::from_code(ObjectBits::decode(minor_key_)); + } + + 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 {}; class ValueBits: public BitField {}; class AddressBits: public BitField {}; 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); }; @@ -348,9 +361,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); }; @@ -359,7 +373,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); @@ -395,11 +411,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); }; diff --git a/src/mips64/code-stubs-mips64.cc b/src/mips64/code-stubs-mips64.cc index ff76fb414c..7381493181 100644 --- a/src/mips64/code-stubs-mips64.cc +++ b/src/mips64/code-stubs-mips64.cc @@ -143,107 +143,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) { -#ifndef BIG_ENDIAN_FLOATING_POINT - Register exponent = result1_; - Register mantissa = result2_; -#else - Register exponent = result2_; - Register mantissa = result1_; -#endif - Label not_special; - // Convert from Smi to integer. - __ 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)); - // Subtract from 0 if source was negative. - __ subu(at, zero_reg, source_); - __ Movn(source_, at, exponent); - - // 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). - __ Branch(¬_special, gt, source_, Operand(1)); - - // 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; - // Safe to use 'at' as dest reg here. - __ Or(at, exponent, Operand(exponent_word_for_1)); - __ Movn(exponent, at, source_); // Write exp when source not 0. - // 1, 0 and -1 all have 0 for the second word. - __ Ret(USE_DELAY_SLOT); - __ mov(mantissa, zero_reg); - - __ bind(¬_special); - // Count leading zeros. - // Gets the wrong answer for 0, but we already checked for that case above. - __ Clz(zeros_, source_); - // Compute exponent and or it into the exponent register. - // We use mantissa as a scratch register here. - __ li(mantissa, Operand(31 + HeapNumber::kExponentBias)); - __ subu(mantissa, mantissa, zeros_); - __ sll(mantissa, mantissa, HeapNumber::kExponentShift); - __ Or(exponent, exponent, mantissa); - - // Shift up the source chopping the top bit off. - __ Addu(zeros_, zeros_, Operand(1)); - // This wouldn't work for 1.0 or -1.0 as the shift would be 32 which means 0. - __ sllv(source_, source_, zeros_); - // Compute lower part of fraction (last 12 bits). - __ sll(mantissa, source_, HeapNumber::kMantissaBitsInTopWord); - // And the top (top 20 bits). - __ srl(source_, source_, 32 - HeapNumber::kMantissaBitsInTopWord); - - __ Ret(USE_DELAY_SLOT); - __ or_(exponent, exponent, source_); -} - - void DoubleToIStub::Generate(MacroAssembler* masm) { Label out_of_range, only_low, negate, done; Register input_reg = source(); @@ -397,32 +296,32 @@ void WriteInt32ToHeapNumberStub::Generate(MacroAssembler* masm) { // We test for the special value that has a different exponent. STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u); // Test sign, and save for later conditionals. - __ And(sign_, the_int_, Operand(0x80000000u)); - __ Branch(&max_negative_int, eq, the_int_, Operand(0x80000000u)); + __ And(sign(), the_int(), Operand(0x80000000u)); + __ Branch(&max_negative_int, eq, the_int(), Operand(0x80000000u)); // 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; - __ li(scratch_, Operand(non_smi_exponent)); + __ li(scratch(), Operand(non_smi_exponent)); // Set the sign bit in scratch_ if the value was negative. - __ or_(scratch_, scratch_, sign_); + __ or_(scratch(), scratch(), sign()); // Subtract from 0 if the value was negative. - __ subu(at, zero_reg, the_int_); - __ Movn(the_int_, at, sign_); + __ subu(at, zero_reg, the_int()); + __ Movn(the_int(), at, sign()); // 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; - __ srl(at, the_int_, shift_distance); - __ or_(scratch_, scratch_, at); - __ sw(scratch_, FieldMemOperand(the_heap_number_, + __ srl(at, the_int(), shift_distance); + __ or_(scratch(), scratch(), at); + __ sw(scratch(), FieldMemOperand(the_heap_number(), HeapNumber::kExponentOffset)); - __ sll(scratch_, the_int_, 32 - shift_distance); + __ sll(scratch(), the_int(), 32 - shift_distance); __ Ret(USE_DELAY_SLOT); - __ sw(scratch_, FieldMemOperand(the_heap_number_, + __ sw(scratch(), FieldMemOperand(the_heap_number(), HeapNumber::kMantissaOffset)); __ bind(&max_negative_int); @@ -431,13 +330,13 @@ void WriteInt32ToHeapNumberStub::Generate(MacroAssembler* masm) { // The actual mantissa bits stored are all 0 because the implicit most // significant 1 bit is not stored. non_smi_exponent += 1 << HeapNumber::kExponentShift; - __ li(scratch_, Operand(HeapNumber::kSignMask | non_smi_exponent)); - __ sw(scratch_, - FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset)); - __ mov(scratch_, zero_reg); + __ li(scratch(), Operand(HeapNumber::kSignMask | non_smi_exponent)); + __ sw(scratch(), + FieldMemOperand(the_heap_number(), HeapNumber::kExponentOffset)); + __ mov(scratch(), zero_reg); __ Ret(USE_DELAY_SLOT); - __ sw(scratch_, - FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset)); + __ sw(scratch(), + FieldMemOperand(the_heap_number(), HeapNumber::kMantissaOffset)); } @@ -4264,7 +4163,7 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) { // Stop if found the property. __ Branch(&in_dictionary, eq, entry_key, Operand(key)); - if (i != kTotalProbes - 1 && mode_ == NEGATIVE_LOOKUP) { + if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) { // Check if the entry name is not a unique name. __ ld(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset)); __ lbu(entry_key, @@ -4277,7 +4176,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) { __ Ret(USE_DELAY_SLOT); __ mov(result, zero_reg); } @@ -4321,11 +4220,11 @@ void RecordWriteStub::Generate(MacroAssembler* masm) { __ beq(zero_reg, zero_reg, &skip_to_incremental_compacting); __ nop(); - 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(); @@ -4347,7 +4246,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; __ ld(regs_.scratch0(), MemOperand(regs_.address(), 0)); @@ -4367,10 +4266,10 @@ 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); @@ -4385,7 +4284,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 = @@ -4401,7 +4300,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()); } @@ -4429,10 +4328,10 @@ 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(); @@ -4473,10 +4372,10 @@ 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/mips64/code-stubs-mips64.h b/src/mips64/code-stubs-mips64.h index 5cb00044d4..cff511f026 100644 --- a/src/mips64/code-stubs-mips64.h +++ b/src/mips64/code-stubs-mips64.h @@ -103,29 +103,42 @@ class RestoreRegistersStateStub: public PlatformCodeStub { // 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, + WriteInt32ToHeapNumberStub(Isolate* isolate, Register the_int, + Register the_heap_number, Register scratch, Register scratch2) - : PlatformCodeStub(isolate), - the_int_(the_int), - the_heap_number_(the_heap_number), - scratch_(scratch), - sign_(scratch2) { - DCHECK(IntRegisterBits::is_valid(the_int_.code())); - DCHECK(HeapNumberRegisterBits::is_valid(the_heap_number_.code())); - DCHECK(ScratchRegisterBits::is_valid(scratch_.code())); - DCHECK(SignRegisterBits::is_valid(sign_.code())); + : PlatformCodeStub(isolate) { + minor_key_ = IntRegisterBits::encode(the_int.code()) | + HeapNumberRegisterBits::encode(the_heap_number.code()) | + ScratchRegisterBits::encode(scratch.code()) | + SignRegisterBits::encode(scratch2.code()); + DCHECK(IntRegisterBits::is_valid(the_int.code())); + DCHECK(HeapNumberRegisterBits::is_valid(the_heap_number.code())); + DCHECK(ScratchRegisterBits::is_valid(scratch.code())); + DCHECK(SignRegisterBits::is_valid(scratch2.code())); } static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate); private: - Register the_int_; - Register the_heap_number_; - Register scratch_; - Register sign_; + 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_)); + } + + Register sign() const { + return Register::from_code(SignRegisterBits::decode(minor_key_)); + } // Minor key encoding in 16 bits. class IntRegisterBits: public BitField {}; @@ -133,16 +146,7 @@ class WriteInt32ToHeapNumberStub : public PlatformCodeStub { class ScratchRegisterBits: public BitField {}; class SignRegisterBits: 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()) - | SignRegisterBits::encode(sign_.code()); - } - - void Generate(MacroAssembler* masm); + DISALLOW_COPY_AND_ASSIGN(WriteInt32ToHeapNumberStub); }; @@ -155,14 +159,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 { @@ -296,6 +300,8 @@ class RecordWriteStub: public PlatformCodeStub { kUpdateRememberedSetOnNoNeedToInformIncrementalMarker }; + Major MajorKey() const { return RecordWrite; } + void Generate(MacroAssembler* masm); void GenerateIncremental(MacroAssembler* masm, Mode mode); void CheckNeedsToInformIncrementalMarker( @@ -304,33 +310,40 @@ class RecordWriteStub: public PlatformCodeStub { Mode mode); void InformIncrementalMarker(MacroAssembler* masm); - Major MajorKey() const { return RecordWrite; } - - 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_); - } - void Activate(Code* code) { code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); } + Register object() const { + return Register::from_code(ObjectBits::decode(minor_key_)); + } + + 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 {}; class ValueBits: public BitField {}; class AddressBits: public BitField {}; 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); }; @@ -347,9 +360,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); }; @@ -358,7 +372,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); @@ -394,11 +410,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); };