diff options
Diffstat (limited to 'deps/v8/src/x64/macro-assembler-x64.cc')
| -rw-r--r-- | deps/v8/src/x64/macro-assembler-x64.cc | 610 |
1 files changed, 65 insertions, 545 deletions
diff --git a/deps/v8/src/x64/macro-assembler-x64.cc b/deps/v8/src/x64/macro-assembler-x64.cc index 4255e583e3..e305aaa1a5 100644 --- a/deps/v8/src/x64/macro-assembler-x64.cc +++ b/deps/v8/src/x64/macro-assembler-x64.cc @@ -9,7 +9,7 @@ #include "src/base/utils/random-number-generator.h" #include "src/bootstrapper.h" #include "src/callable.h" -#include "src/codegen.h" +#include "src/code-stubs.h" #include "src/counters.h" #include "src/debug/debug.h" #include "src/external-reference-table.h" @@ -24,6 +24,42 @@ namespace v8 { namespace internal { +Operand StackArgumentsAccessor::GetArgumentOperand(int index) { + DCHECK_GE(index, 0); + int receiver = (receiver_mode_ == ARGUMENTS_CONTAIN_RECEIVER) ? 1 : 0; + int displacement_to_last_argument = + base_reg_ == rsp ? kPCOnStackSize : kFPOnStackSize + kPCOnStackSize; + displacement_to_last_argument += extra_displacement_to_last_argument_; + if (argument_count_reg_ == no_reg) { + // argument[0] is at base_reg_ + displacement_to_last_argument + + // (argument_count_immediate_ + receiver - 1) * kPointerSize. + DCHECK_GT(argument_count_immediate_ + receiver, 0); + return Operand( + base_reg_, + displacement_to_last_argument + + (argument_count_immediate_ + receiver - 1 - index) * kPointerSize); + } else { + // argument[0] is at base_reg_ + displacement_to_last_argument + + // argument_count_reg_ * times_pointer_size + (receiver - 1) * kPointerSize. + return Operand( + base_reg_, argument_count_reg_, times_pointer_size, + displacement_to_last_argument + (receiver - 1 - index) * kPointerSize); + } +} + +StackArgumentsAccessor::StackArgumentsAccessor( + Register base_reg, const ParameterCount& parameter_count, + StackArgumentsAccessorReceiverMode receiver_mode, + int extra_displacement_to_last_argument) + : base_reg_(base_reg), + argument_count_reg_(parameter_count.is_reg() ? parameter_count.reg() + : no_reg), + argument_count_immediate_( + parameter_count.is_immediate() ? parameter_count.immediate() : 0), + receiver_mode_(receiver_mode), + extra_displacement_to_last_argument_( + extra_displacement_to_last_argument) {} + MacroAssembler::MacroAssembler(Isolate* isolate, void* buffer, int size, CodeObjectRequired create_code_object) : TurboAssembler(isolate, buffer, size, create_code_object) {} @@ -184,50 +220,6 @@ void TurboAssembler::CompareRoot(const Operand& with, cmpp(with, kScratchRegister); } -void MacroAssembler::RememberedSetHelper(Register object, // For debug tests. - Register addr, Register scratch, - SaveFPRegsMode save_fp) { - if (emit_debug_code()) { - Label ok; - JumpIfNotInNewSpace(object, scratch, &ok, Label::kNear); - int3(); - bind(&ok); - } - // Load store buffer top. - ExternalReference store_buffer = - ExternalReference::store_buffer_top(isolate()); - DCHECK(scratch != kScratchRegister); - Move(kScratchRegister, store_buffer); - movp(scratch, Operand(kScratchRegister, 0)); - // Store pointer to buffer. - movp(Operand(scratch, 0), addr); - // Increment buffer top. - addp(scratch, Immediate(kPointerSize)); - // Write back new top of buffer. - movp(Operand(kScratchRegister, 0), scratch); - // Call stub on end of buffer. - Label done; - // Check for end of buffer. - testp(scratch, Immediate(StoreBuffer::kStoreBufferMask)); - Label buffer_overflowed; - j(equal, &buffer_overflowed, Label::kNear); - ret(0); - bind(&buffer_overflowed); - StoreBufferOverflowStub store_buffer_overflow(isolate(), save_fp); - CallStub(&store_buffer_overflow); - ret(0); -} - - -void MacroAssembler::InNewSpace(Register object, - Register scratch, - Condition cc, - Label* branch, - Label::Distance distance) { - CheckPageFlag(object, scratch, MemoryChunk::kIsInNewSpaceMask, cc, branch, - distance); -} - void MacroAssembler::RecordWriteField(Register object, int offset, Register value, Register dst, SaveFPRegsMode save_fp, @@ -269,7 +261,7 @@ void MacroAssembler::RecordWriteField(Register object, int offset, } void TurboAssembler::SaveRegisters(RegList registers) { - DCHECK(NumRegs(registers) > 0); + DCHECK_GT(NumRegs(registers), 0); for (int i = 0; i < Register::kNumRegisters; ++i) { if ((registers >> i) & 1u) { pushq(Register::from_code(i)); @@ -278,7 +270,7 @@ void TurboAssembler::SaveRegisters(RegList registers) { } void TurboAssembler::RestoreRegisters(RegList registers) { - DCHECK(NumRegs(registers) > 0); + DCHECK_GT(NumRegs(registers), 0); for (int i = Register::kNumRegisters - 1; i >= 0; --i) { if ((registers >> i) & 1u) { popq(Register::from_code(i)); @@ -363,13 +355,7 @@ void MacroAssembler::RecordWrite(Register object, Register address, &done, Label::kNear); -#ifdef V8_CSA_WRITE_BARRIER CallRecordWriteStub(object, address, remembered_set_action, fp_mode); -#else - RecordWriteStub stub(isolate(), object, value, address, remembered_set_action, - fp_mode); - CallStub(&stub); -#endif bind(&done); @@ -418,7 +404,7 @@ void TurboAssembler::CheckStackAlignment() { void TurboAssembler::Abort(BailoutReason reason) { #ifdef DEBUG const char* msg = GetBailoutReason(reason); - if (msg != NULL) { + if (msg != nullptr) { RecordComment("Abort message: "); RecordComment(msg); } @@ -960,24 +946,6 @@ void MacroAssembler::SmiToInteger64(Register dst, Register src) { } } - -void MacroAssembler::SmiToInteger64(Register dst, const Operand& src) { - if (SmiValuesAre32Bits()) { - movsxlq(dst, Operand(src, kSmiShift / kBitsPerByte)); - } else { - DCHECK(SmiValuesAre31Bits()); - movp(dst, src); - SmiToInteger64(dst, dst); - } -} - - -void MacroAssembler::SmiTest(Register src) { - AssertSmi(src); - testp(src, src); -} - - void MacroAssembler::SmiCompare(Register smi1, Register smi2) { AssertSmi(smi1); AssertSmi(smi2); @@ -992,7 +960,7 @@ void MacroAssembler::SmiCompare(Register dst, Smi* src) { void MacroAssembler::Cmp(Register dst, Smi* src) { - DCHECK(dst != kScratchRegister); + DCHECK_NE(dst, kScratchRegister); if (src->value() == 0) { testp(dst, dst); } else { @@ -1035,25 +1003,6 @@ void MacroAssembler::Cmp(const Operand& dst, Smi* src) { } -void MacroAssembler::PositiveSmiTimesPowerOfTwoToInteger64(Register dst, - Register src, - int power) { - DCHECK(power >= 0); - DCHECK(power < 64); - if (power == 0) { - SmiToInteger64(dst, src); - return; - } - if (dst != src) { - movp(dst, src); - } - if (power < kSmiShift) { - sarp(dst, Immediate(kSmiShift - power)); - } else if (power > kSmiShift) { - shlp(dst, Immediate(power - kSmiShift)); - } -} - Condition TurboAssembler::CheckSmi(Register src) { STATIC_ASSERT(kSmiTag == 0); testb(src, Immediate(kSmiTagMask)); @@ -1086,23 +1035,6 @@ void MacroAssembler::JumpIfNotSmi(Operand src, Label* on_not_smi, j(NegateCondition(smi), on_not_smi, near_jump); } -void MacroAssembler::SmiAddConstant(Register dst, Register src, Smi* constant) { - if (constant->value() == 0) { - if (dst != src) { - movp(dst, src); - } - return; - } else if (dst == src) { - DCHECK(dst != kScratchRegister); - Register constant_reg = GetSmiConstant(constant); - addp(dst, constant_reg); - } else { - Move(dst, constant); - addp(dst, src); - } -} - - void MacroAssembler::SmiAddConstant(const Operand& dst, Smi* constant) { if (constant->value() != 0) { if (SmiValuesAre32Bits()) { @@ -1115,248 +1047,6 @@ void MacroAssembler::SmiAddConstant(const Operand& dst, Smi* constant) { } } -void MacroAssembler::SmiAddConstant(Register dst, Register src, Smi* constant, - SmiOperationConstraints constraints, - Label* bailout_label, - Label::Distance near_jump) { - if (constant->value() == 0) { - if (dst != src) { - movp(dst, src); - } - } else if (dst == src) { - DCHECK(dst != kScratchRegister); - Move(kScratchRegister, constant); - addp(dst, kScratchRegister); - if (constraints & SmiOperationConstraint::kBailoutOnNoOverflow) { - j(no_overflow, bailout_label, near_jump); - DCHECK(constraints & SmiOperationConstraint::kPreserveSourceRegister); - subp(dst, kScratchRegister); - } else if (constraints & SmiOperationConstraint::kBailoutOnOverflow) { - if (constraints & SmiOperationConstraint::kPreserveSourceRegister) { - Label done; - j(no_overflow, &done, Label::kNear); - subp(dst, kScratchRegister); - jmp(bailout_label, near_jump); - bind(&done); - } else { - // Bailout if overflow without reserving src. - j(overflow, bailout_label, near_jump); - } - } else { - UNREACHABLE(); - } - } else { - DCHECK(constraints & SmiOperationConstraint::kPreserveSourceRegister); - DCHECK(constraints & SmiOperationConstraint::kBailoutOnOverflow); - Move(dst, constant); - addp(dst, src); - j(overflow, bailout_label, near_jump); - } -} - -void MacroAssembler::SmiSubConstant(Register dst, Register src, Smi* constant) { - if (constant->value() == 0) { - if (dst != src) { - movp(dst, src); - } - } else if (dst == src) { - DCHECK(dst != kScratchRegister); - Register constant_reg = GetSmiConstant(constant); - subp(dst, constant_reg); - } else { - if (constant->value() == Smi::kMinValue) { - Move(dst, constant); - // Adding and subtracting the min-value gives the same result, it only - // differs on the overflow bit, which we don't check here. - addp(dst, src); - } else { - // Subtract by adding the negation. - Move(dst, Smi::FromInt(-constant->value())); - addp(dst, src); - } - } -} - -void MacroAssembler::SmiSubConstant(Register dst, Register src, Smi* constant, - SmiOperationConstraints constraints, - Label* bailout_label, - Label::Distance near_jump) { - if (constant->value() == 0) { - if (dst != src) { - movp(dst, src); - } - } else if (dst == src) { - DCHECK(dst != kScratchRegister); - Move(kScratchRegister, constant); - subp(dst, kScratchRegister); - if (constraints & SmiOperationConstraint::kBailoutOnNoOverflow) { - j(no_overflow, bailout_label, near_jump); - DCHECK(constraints & SmiOperationConstraint::kPreserveSourceRegister); - addp(dst, kScratchRegister); - } else if (constraints & SmiOperationConstraint::kBailoutOnOverflow) { - if (constraints & SmiOperationConstraint::kPreserveSourceRegister) { - Label done; - j(no_overflow, &done, Label::kNear); - addp(dst, kScratchRegister); - jmp(bailout_label, near_jump); - bind(&done); - } else { - // Bailout if overflow without reserving src. - j(overflow, bailout_label, near_jump); - } - } else { - UNREACHABLE(); - } - } else { - DCHECK(constraints & SmiOperationConstraint::kPreserveSourceRegister); - DCHECK(constraints & SmiOperationConstraint::kBailoutOnOverflow); - if (constant->value() == Smi::kMinValue) { - DCHECK(dst != kScratchRegister); - movp(dst, src); - Move(kScratchRegister, constant); - subp(dst, kScratchRegister); - j(overflow, bailout_label, near_jump); - } else { - // Subtract by adding the negation. - Move(dst, Smi::FromInt(-(constant->value()))); - addp(dst, src); - j(overflow, bailout_label, near_jump); - } - } -} - -template<class T> -static void SmiAddHelper(MacroAssembler* masm, - Register dst, - Register src1, - T src2, - Label* on_not_smi_result, - Label::Distance near_jump) { - if (dst == src1) { - Label done; - masm->addp(dst, src2); - masm->j(no_overflow, &done, Label::kNear); - // Restore src1. - masm->subp(dst, src2); - masm->jmp(on_not_smi_result, near_jump); - masm->bind(&done); - } else { - masm->movp(dst, src1); - masm->addp(dst, src2); - masm->j(overflow, on_not_smi_result, near_jump); - } -} - - -void MacroAssembler::SmiAdd(Register dst, - Register src1, - Register src2, - Label* on_not_smi_result, - Label::Distance near_jump) { - DCHECK_NOT_NULL(on_not_smi_result); - DCHECK(dst != src2); - SmiAddHelper<Register>(this, dst, src1, src2, on_not_smi_result, near_jump); -} - - -void MacroAssembler::SmiAdd(Register dst, - Register src1, - const Operand& src2, - Label* on_not_smi_result, - Label::Distance near_jump) { - DCHECK_NOT_NULL(on_not_smi_result); - DCHECK(!src2.AddressUsesRegister(dst)); - SmiAddHelper<Operand>(this, dst, src1, src2, on_not_smi_result, near_jump); -} - -void MacroAssembler::SmiAdd(Register dst, - Register src1, - Register src2) { - // No overflow checking. Use only when it's known that - // overflowing is impossible. - if (dst != src1) { - if (emit_debug_code()) { - movp(kScratchRegister, src1); - addp(kScratchRegister, src2); - Check(no_overflow, kSmiAdditionOverflow); - } - leap(dst, Operand(src1, src2, times_1, 0)); - } else { - addp(dst, src2); - Assert(no_overflow, kSmiAdditionOverflow); - } -} - - -template<class T> -static void SmiSubHelper(MacroAssembler* masm, - Register dst, - Register src1, - T src2, - Label* on_not_smi_result, - Label::Distance near_jump) { - if (dst == src1) { - Label done; - masm->subp(dst, src2); - masm->j(no_overflow, &done, Label::kNear); - // Restore src1. - masm->addp(dst, src2); - masm->jmp(on_not_smi_result, near_jump); - masm->bind(&done); - } else { - masm->movp(dst, src1); - masm->subp(dst, src2); - masm->j(overflow, on_not_smi_result, near_jump); - } -} - -void MacroAssembler::SmiSub(Register dst, - Register src1, - Register src2, - Label* on_not_smi_result, - Label::Distance near_jump) { - DCHECK_NOT_NULL(on_not_smi_result); - DCHECK(dst != src2); - SmiSubHelper<Register>(this, dst, src1, src2, on_not_smi_result, near_jump); -} - -void MacroAssembler::SmiSub(Register dst, - Register src1, - const Operand& src2, - Label* on_not_smi_result, - Label::Distance near_jump) { - DCHECK_NOT_NULL(on_not_smi_result); - DCHECK(!src2.AddressUsesRegister(dst)); - SmiSubHelper<Operand>(this, dst, src1, src2, on_not_smi_result, near_jump); -} - -template<class T> -static void SmiSubNoOverflowHelper(MacroAssembler* masm, - Register dst, - Register src1, - T src2) { - // No overflow checking. Use only when it's known that - // overflowing is impossible (e.g., subtracting two positive smis). - if (dst != src1) { - masm->movp(dst, src1); - } - masm->subp(dst, src2); - masm->Assert(no_overflow, kSmiSubtractionOverflow); -} - - -void MacroAssembler::SmiSub(Register dst, Register src1, Register src2) { - DCHECK(dst != src2); - SmiSubNoOverflowHelper<Register>(this, dst, src1, src2); -} - - -void MacroAssembler::SmiSub(Register dst, - Register src1, - const Operand& src2) { - SmiSubNoOverflowHelper<Operand>(this, dst, src1, src2); -} - SmiIndex MacroAssembler::SmiToIndex(Register dst, Register src, int shift) { @@ -1411,36 +1101,6 @@ void TurboAssembler::Push(Smi* source) { // ---------------------------------------------------------------------------- -template<class T> -static void JumpIfNotUniqueNameHelper(MacroAssembler* masm, - T operand_or_register, - Label* not_unique_name, - Label::Distance distance) { - STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0); - Label succeed; - masm->testb(operand_or_register, - Immediate(kIsNotStringMask | kIsNotInternalizedMask)); - masm->j(zero, &succeed, Label::kNear); - masm->cmpb(operand_or_register, Immediate(static_cast<uint8_t>(SYMBOL_TYPE))); - masm->j(not_equal, not_unique_name, distance); - - masm->bind(&succeed); -} - - -void MacroAssembler::JumpIfNotUniqueNameInstanceType(Operand operand, - Label* not_unique_name, - Label::Distance distance) { - JumpIfNotUniqueNameHelper<Operand>(this, operand, not_unique_name, distance); -} - - -void MacroAssembler::JumpIfNotUniqueNameInstanceType(Register reg, - Label* not_unique_name, - Label::Distance distance) { - JumpIfNotUniqueNameHelper<Register>(this, reg, not_unique_name, distance); -} - void TurboAssembler::Move(Register dst, Register src) { if (dst != src) { movp(dst, src); @@ -1460,7 +1120,7 @@ void TurboAssembler::Move(XMMRegister dst, uint32_t src) { if (src == 0) { Xorpd(dst, dst); } else { - unsigned pop = base::bits::CountPopulation32(src); + unsigned pop = base::bits::CountPopulation(src); DCHECK_NE(0u, pop); if (pop == 32) { Pcmpeqd(dst, dst); @@ -1475,9 +1135,9 @@ void TurboAssembler::Move(XMMRegister dst, uint64_t src) { if (src == 0) { Xorpd(dst, dst); } else { - unsigned nlz = base::bits::CountLeadingZeros64(src); - unsigned ntz = base::bits::CountTrailingZeros64(src); - unsigned pop = base::bits::CountPopulation64(src); + unsigned nlz = base::bits::CountLeadingZeros(src); + unsigned ntz = base::bits::CountTrailingZeros(src); + unsigned pop = base::bits::CountPopulation(src); DCHECK_NE(0u, pop); if (pop == 64) { Pcmpeqd(dst, dst); @@ -1813,19 +1473,6 @@ void TurboAssembler::Move(const Operand& dst, Handle<HeapObject> object, movp(dst, kScratchRegister); } -void MacroAssembler::GetWeakValue(Register value, Handle<WeakCell> cell) { - Move(value, cell, RelocInfo::EMBEDDED_OBJECT); - movp(value, FieldOperand(value, WeakCell::kValueOffset)); -} - - -void MacroAssembler::LoadWeakValue(Register value, Handle<WeakCell> cell, - Label* miss) { - GetWeakValue(value, cell); - JumpIfSmi(value, miss); -} - - void MacroAssembler::Drop(int stack_elements) { if (stack_elements > 0) { addp(rsp, Immediate(stack_elements * kPointerSize)); @@ -1835,7 +1482,7 @@ void MacroAssembler::Drop(int stack_elements) { void MacroAssembler::DropUnderReturnAddress(int stack_elements, Register scratch) { - DCHECK(stack_elements > 0); + DCHECK_GT(stack_elements, 0); if (kPointerSize == kInt64Size && stack_elements == 1) { popq(MemOperand(rsp, 0)); return; @@ -2315,14 +1962,11 @@ void MacroAssembler::CmpObjectType(Register heap_object, void MacroAssembler::CmpInstanceType(Register map, InstanceType type) { - cmpb(FieldOperand(map, Map::kInstanceTypeOffset), - Immediate(static_cast<int8_t>(type))); + cmpw(FieldOperand(map, Map::kInstanceTypeOffset), Immediate(type)); } -void TurboAssembler::SlowTruncateToIDelayed(Zone* zone, Register result_reg, - Register input_reg, int offset) { - CallStubDelayed( - new (zone) DoubleToIStub(nullptr, input_reg, result_reg, offset, true)); +void TurboAssembler::SlowTruncateToIDelayed(Zone* zone, Register result_reg) { + CallStubDelayed(new (zone) DoubleToIStub(nullptr, result_reg)); } void MacroAssembler::DoubleToI(Register result_reg, XMMRegister input_reg, @@ -2352,23 +1996,6 @@ void MacroAssembler::DoubleToI(Register result_reg, XMMRegister input_reg, } -void MacroAssembler::LoadInstanceDescriptors(Register map, - Register descriptors) { - movp(descriptors, FieldOperand(map, Map::kDescriptorsOffset)); -} - -void MacroAssembler::LoadAccessor(Register dst, Register holder, - int accessor_index, - AccessorComponent accessor) { - movp(dst, FieldOperand(holder, HeapObject::kMapOffset)); - LoadInstanceDescriptors(dst, dst); - movp(dst, FieldOperand(dst, DescriptorArray::GetValueOffset(accessor_index))); - int offset = accessor == ACCESSOR_GETTER ? AccessorPair::kGetterOffset - : AccessorPair::kSetterOffset; - movp(dst, FieldOperand(dst, offset)); -} - - void MacroAssembler::AssertNotSmi(Register object) { if (emit_debug_code()) { Condition is_smi = CheckSmi(object); @@ -2405,7 +2032,7 @@ void MacroAssembler::AssertFixedArray(Register object) { void TurboAssembler::AssertZeroExtended(Register int32_register) { if (emit_debug_code()) { - DCHECK(int32_register != kScratchRegister); + DCHECK_NE(int32_register, kScratchRegister); movq(kScratchRegister, V8_INT64_C(0x0000000100000000)); cmpq(kScratchRegister, int32_register); Check(above_equal, k32BitValueInRegisterIsNotZeroExtended); @@ -2472,21 +2099,8 @@ void MacroAssembler::AssertUndefinedOrAllocationSite(Register object) { } } -void MacroAssembler::GetMapConstructor(Register result, Register map, - Register temp) { - Label done, loop; - movp(result, FieldOperand(map, Map::kConstructorOrBackPointerOffset)); - bind(&loop); - JumpIfSmi(result, &done, Label::kNear); - CmpObjectType(result, MAP_TYPE, temp); - j(not_equal, &done, Label::kNear); - movp(result, FieldOperand(result, Map::kConstructorOrBackPointerOffset)); - jmp(&loop); - bind(&done); -} - void MacroAssembler::IncrementCounter(StatsCounter* counter, int value) { - DCHECK(value > 0); + DCHECK_GT(value, 0); if (FLAG_native_code_counters && counter->Enabled()) { Operand counter_operand = ExternalOperand(ExternalReference(counter)); if (value == 1) { @@ -2499,7 +2113,7 @@ void MacroAssembler::IncrementCounter(StatsCounter* counter, int value) { void MacroAssembler::DecrementCounter(StatsCounter* counter, int value) { - DCHECK(value > 0); + DCHECK_GT(value, 0); if (FLAG_native_code_counters && counter->Enabled()) { Operand counter_operand = ExternalOperand(ExternalReference(counter)); if (value == 1) { @@ -2522,8 +2136,7 @@ void MacroAssembler::MaybeDropFrames() { void TurboAssembler::PrepareForTailCall(const ParameterCount& callee_args_count, Register caller_args_count_reg, - Register scratch0, Register scratch1, - ReturnAddressState ra_state) { + Register scratch0, Register scratch1) { #if DEBUG if (callee_args_count.is_reg()) { DCHECK(!AreAliased(callee_args_count.reg(), caller_args_count_reg, scratch0, @@ -2555,13 +2168,8 @@ void TurboAssembler::PrepareForTailCall(const ParameterCount& callee_args_count, // to avoid its trashing and let the following loop copy it to the right // place. Register tmp_reg = scratch1; - if (ra_state == ReturnAddressState::kOnStack) { - movp(tmp_reg, Operand(rbp, StandardFrameConstants::kCallerPCOffset)); - movp(Operand(rsp, 0), tmp_reg); - } else { - DCHECK(ReturnAddressState::kNotOnStack == ra_state); - Push(Operand(rbp, StandardFrameConstants::kCallerPCOffset)); - } + movp(tmp_reg, Operand(rbp, StandardFrameConstants::kCallerPCOffset)); + movp(Operand(rsp, 0), tmp_reg); // Restore caller's frame pointer now as it could be overwritten by // the copying loop. @@ -2923,26 +2531,22 @@ void MacroAssembler::LeaveExitFrame(bool save_doubles, bool pop_arguments) { leave(); } - LeaveExitFrameEpilogue(true); + LeaveExitFrameEpilogue(); } - -void MacroAssembler::LeaveApiExitFrame(bool restore_context) { +void MacroAssembler::LeaveApiExitFrame() { movp(rsp, rbp); popq(rbp); - LeaveExitFrameEpilogue(restore_context); + LeaveExitFrameEpilogue(); } - -void MacroAssembler::LeaveExitFrameEpilogue(bool restore_context) { +void MacroAssembler::LeaveExitFrameEpilogue() { // Restore current context from top and clear it in debug mode. ExternalReference context_address(IsolateAddressId::kContextAddress, isolate()); Operand context_operand = ExternalOperand(context_address); - if (restore_context) { - movp(rsi, context_operand); - } + movp(rsi, context_operand); #ifdef DEBUG movp(context_operand, Immediate(0)); #endif @@ -2975,7 +2579,7 @@ int TurboAssembler::ArgumentStackSlotsForCFunctionCall(int num_arguments) { // arguments. // On AMD64 ABI (Linux/Mac) the first six arguments are passed in registers // and the caller does not reserve stack slots for them. - DCHECK(num_arguments >= 0); + DCHECK_GE(num_arguments, 0); #ifdef _WIN64 const int kMinimumStackSlots = kRegisterPassedArguments; if (num_arguments < kMinimumStackSlots) return kMinimumStackSlots; @@ -2988,8 +2592,8 @@ int TurboAssembler::ArgumentStackSlotsForCFunctionCall(int num_arguments) { void TurboAssembler::PrepareCallCFunction(int num_arguments) { int frame_alignment = base::OS::ActivationFrameAlignment(); - DCHECK(frame_alignment != 0); - DCHECK(num_arguments >= 0); + DCHECK_NE(frame_alignment, 0); + DCHECK_GE(num_arguments, 0); // Make stack end at alignment and allocate space for arguments and old rsp. movp(kScratchRegister, rsp); @@ -3016,8 +2620,8 @@ void TurboAssembler::CallCFunction(Register function, int num_arguments) { } call(function); - DCHECK(base::OS::ActivationFrameAlignment() != 0); - DCHECK(num_arguments >= 0); + DCHECK_NE(base::OS::ActivationFrameAlignment(), 0); + DCHECK_GE(num_arguments, 0); int argument_slots_on_stack = ArgumentStackSlotsForCFunctionCall(num_arguments); movp(rsp, Operand(rsp, argument_slots_on_stack * kRegisterSize)); @@ -3052,27 +2656,6 @@ bool AreAliased(Register reg1, } #endif - -CodePatcher::CodePatcher(Isolate* isolate, byte* address, int size) - : address_(address), - size_(size), - masm_(isolate, address, size + Assembler::kGap, CodeObjectRequired::kNo) { - // Create a new macro assembler pointing to the address of the code to patch. - // The size is adjusted with kGap on order for the assembler to generate size - // bytes of instructions without failing with buffer size constraints. - DCHECK(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap); -} - - -CodePatcher::~CodePatcher() { - // Indicate that code has changed. - Assembler::FlushICache(masm_.isolate(), address_, size_); - - // Check that the code was patched as expected. - DCHECK(masm_.pc_ == address_ + size_); - DCHECK(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap); -} - void TurboAssembler::CheckPageFlag(Register object, Register scratch, int mask, Condition cc, Label* condition_met, Label::Distance condition_met_distance) { @@ -3091,69 +2674,6 @@ void TurboAssembler::CheckPageFlag(Register object, Register scratch, int mask, } j(cc, condition_met, condition_met_distance); } - - -void MacroAssembler::JumpIfBlack(Register object, - Register bitmap_scratch, - Register mask_scratch, - Label* on_black, - Label::Distance on_black_distance) { - DCHECK(!AreAliased(object, bitmap_scratch, mask_scratch, rcx)); - - GetMarkBits(object, bitmap_scratch, mask_scratch); - - DCHECK(strcmp(Marking::kBlackBitPattern, "11") == 0); - // The mask_scratch register contains a 1 at the position of the first bit - // and a 1 at a position of the second bit. All other positions are zero. - movp(rcx, mask_scratch); - andp(rcx, Operand(bitmap_scratch, MemoryChunk::kHeaderSize)); - cmpp(mask_scratch, rcx); - j(equal, on_black, on_black_distance); -} - - -void MacroAssembler::GetMarkBits(Register addr_reg, - Register bitmap_reg, - Register mask_reg) { - DCHECK(!AreAliased(addr_reg, bitmap_reg, mask_reg, rcx)); - movp(bitmap_reg, addr_reg); - // Sign extended 32 bit immediate. - andp(bitmap_reg, Immediate(~Page::kPageAlignmentMask)); - movp(rcx, addr_reg); - int shift = - Bitmap::kBitsPerCellLog2 + kPointerSizeLog2 - Bitmap::kBytesPerCellLog2; - shrl(rcx, Immediate(shift)); - andp(rcx, - Immediate((Page::kPageAlignmentMask >> shift) & - ~(Bitmap::kBytesPerCell - 1))); - - addp(bitmap_reg, rcx); - movp(rcx, addr_reg); - shrl(rcx, Immediate(kPointerSizeLog2)); - andp(rcx, Immediate((1 << Bitmap::kBitsPerCellLog2) - 1)); - movl(mask_reg, Immediate(3)); - shlp_cl(mask_reg); -} - - -void MacroAssembler::JumpIfWhite(Register value, Register bitmap_scratch, - Register mask_scratch, Label* value_is_white, - Label::Distance distance) { - DCHECK(!AreAliased(value, bitmap_scratch, mask_scratch, rcx)); - GetMarkBits(value, bitmap_scratch, mask_scratch); - - // If the value is black or grey we don't need to do anything. - DCHECK(strcmp(Marking::kWhiteBitPattern, "00") == 0); - DCHECK(strcmp(Marking::kBlackBitPattern, "11") == 0); - DCHECK(strcmp(Marking::kGreyBitPattern, "10") == 0); - DCHECK(strcmp(Marking::kImpossibleBitPattern, "01") == 0); - - // Since both black and grey have a 1 in the first position and white does - // not have a 1 there we only need to check one bit. - testp(Operand(bitmap_scratch, MemoryChunk::kHeaderSize), mask_scratch); - j(zero, value_is_white, distance); -} - } // namespace internal } // namespace v8 |