Skip to content

V
V8
Commit de72001f authored by haitao.feng@intel.com's avatar haitao.feng@intel.com
Browse files
Options

Replace movq with movp for X64 when the operand size is kPointerSize 

R=verwaest@chromium.org

Review URL: https://codereview.chromium.org/105503006

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@18675 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent 5c122cd4
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1051 additions and 1051 deletions
src/x64/builtins-x64.cc
View file @ de72001f
This diff is collapsed.
src/x64/code-stubs-x64.cc
View file @ de72001f
This diff is collapsed.
src/x64/code-stubs-x64.h
View file @ de72001f
......@@ -362,11 +362,11 @@ class RecordWriteStub: public PlatformCodeStub {
masm->push(scratch1_);
if (!address_.is(address_orig_)) {
masm->push(address_);
masm->movq(address_, address_orig_);
masm->movp(address_, address_orig_);
}
if (!object_.is(object_orig_)) {
masm->push(object_);
masm->movq(object_, object_orig_);
masm->movp(object_, object_orig_);
}
}
......@@ -375,11 +375,11 @@ class RecordWriteStub: public PlatformCodeStub {
// them back. Only in one case is the orig_ reg different from the plain
// one, since only one of them can alias with rcx.
if (!object_.is(object_orig_)) {
masm->movq(object_orig_, object_);
masm->movp(object_orig_, object_);
masm->pop(object_);
}
if (!address_.is(address_orig_)) {
masm->movq(address_orig_, address_);
masm->movp(address_orig_, address_);
masm->pop(address_);
}
masm->pop(scratch1_);
......
src/x64/codegen-x64.cc
View file @ de72001f
......@@ -170,7 +170,7 @@ ModuloFunction CreateModuloFunction() {
__ fstp(0); // Drop result in st(0).
int64_t kNaNValue = V8_INT64_C(0x7ff8000000000000);
__ movq(rcx, kNaNValue);
__ movq(Operand(rsp, kPointerSize), rcx);
__ movp(Operand(rsp, kPointerSize), rcx);
__ movsd(xmm0, Operand(rsp, kPointerSize));
__ jmp(&return_result);
......@@ -223,7 +223,7 @@ void ElementsTransitionGenerator::GenerateMapChangeElementsTransition(
}
// Set transitioned map.
__ movq(FieldOperand(rdx, HeapObject::kMapOffset), rbx);
__ movp(FieldOperand(rdx, HeapObject::kMapOffset), rbx);
__ RecordWriteField(rdx,
HeapObject::kMapOffset,
rbx,
......@@ -252,7 +252,7 @@ void ElementsTransitionGenerator::GenerateSmiToDouble(
// Check for empty arrays, which only require a map transition and no changes
// to the backing store.
__ movq(r8, FieldOperand(rdx, JSObject::kElementsOffset));
__ movp(r8, FieldOperand(rdx, JSObject::kElementsOffset));
__ CompareRoot(r8, Heap::kEmptyFixedArrayRootIndex);
__ j(equal, &only_change_map);
......@@ -268,18 +268,18 @@ void ElementsTransitionGenerator::GenerateSmiToDouble(
// the same size.
__ JumpIfNotInNewSpace(r8, rdi, &new_backing_store);
__ movq(r14, r8); // Destination array equals source array.
__ movp(r14, r8); // Destination array equals source array.
// r8 : source FixedArray
// r9 : elements array length
// r14: destination FixedDoubleArray
// Set backing store's map
__ LoadRoot(rdi, Heap::kFixedDoubleArrayMapRootIndex);
__ movq(FieldOperand(r14, HeapObject::kMapOffset), rdi);
__ movp(FieldOperand(r14, HeapObject::kMapOffset), rdi);
__ bind(&allocated);
// Set transitioned map.
__ movq(FieldOperand(rdx, HeapObject::kMapOffset), rbx);
__ movp(FieldOperand(rdx, HeapObject::kMapOffset), rbx);
__ RecordWriteField(rdx,
HeapObject::kMapOffset,
rbx,
......@@ -304,10 +304,10 @@ void ElementsTransitionGenerator::GenerateSmiToDouble(
__ Allocate(rdi, r14, r11, r15, fail, TAG_OBJECT);
// Set backing store's map
__ LoadRoot(rdi, Heap::kFixedDoubleArrayMapRootIndex);
__ movq(FieldOperand(r14, HeapObject::kMapOffset), rdi);
__ movp(FieldOperand(r14, HeapObject::kMapOffset), rdi);
// Set receiver's backing store.
__ movq(FieldOperand(rdx, JSObject::kElementsOffset), r14);
__ movq(r11, r14);
__ movp(FieldOperand(rdx, JSObject::kElementsOffset), r14);
__ movp(r11, r14);
__ RecordWriteField(rdx,
JSObject::kElementsOffset,
r11,
......@@ -317,12 +317,12 @@ void ElementsTransitionGenerator::GenerateSmiToDouble(
OMIT_SMI_CHECK);
// Set backing store's length.
__ Integer32ToSmi(r11, r9);
__ movq(FieldOperand(r14, FixedDoubleArray::kLengthOffset), r11);
__ movp(FieldOperand(r14, FixedDoubleArray::kLengthOffset), r11);
__ jmp(&allocated);
__ bind(&only_change_map);
// Set transitioned map.
__ movq(FieldOperand(rdx, HeapObject::kMapOffset), rbx);
__ movp(FieldOperand(rdx, HeapObject::kMapOffset), rbx);
__ RecordWriteField(rdx,
HeapObject::kMapOffset,
rbx,
......@@ -334,7 +334,7 @@ void ElementsTransitionGenerator::GenerateSmiToDouble(
// Conversion loop.
__ bind(&loop);
__ movq(rbx,
__ movp(rbx,
FieldOperand(r8, r9, times_pointer_size, FixedArray::kHeaderSize));
// r9 : current element's index
// rbx: current element (smi-tagged)
......@@ -377,13 +377,13 @@ void ElementsTransitionGenerator::GenerateDoubleToObject(
// Check for empty arrays, which only require a map transition and no changes
// to the backing store.
__ movq(r8, FieldOperand(rdx, JSObject::kElementsOffset));
__ movp(r8, FieldOperand(rdx, JSObject::kElementsOffset));
__ CompareRoot(r8, Heap::kEmptyFixedArrayRootIndex);
__ j(equal, &only_change_map);
__ push(rax);
__ movq(r8, FieldOperand(rdx, JSObject::kElementsOffset));
__ movp(r8, FieldOperand(rdx, JSObject::kElementsOffset));
__ SmiToInteger32(r9, FieldOperand(r8, FixedDoubleArray::kLengthOffset));
// r8 : source FixedDoubleArray
// r9 : number of elements
......@@ -391,9 +391,9 @@ void ElementsTransitionGenerator::GenerateDoubleToObject(
__ Allocate(rdi, r11, r14, r15, &gc_required, TAG_OBJECT);
// r11: destination FixedArray
__ LoadRoot(rdi, Heap::kFixedArrayMapRootIndex);
__ movq(FieldOperand(r11, HeapObject::kMapOffset), rdi);
__ movp(FieldOperand(r11, HeapObject::kMapOffset), rdi);
__ Integer32ToSmi(r14, r9);
__ movq(FieldOperand(r11, FixedArray::kLengthOffset), r14);
__ movp(FieldOperand(r11, FixedArray::kLengthOffset), r14);
// Prepare for conversion loop.
__ movq(rsi, BitCast<int64_t, uint64_t>(kHoleNanInt64));
......@@ -405,7 +405,7 @@ void ElementsTransitionGenerator::GenerateDoubleToObject(
// Call into runtime if GC is required.
__ bind(&gc_required);
__ pop(rax);
__ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
__ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
__ jmp(fail);
// Box doubles into heap numbers.
......@@ -423,12 +423,12 @@ void ElementsTransitionGenerator::GenerateDoubleToObject(
__ AllocateHeapNumber(rax, r15, &gc_required);
// rax: new heap number
__ MoveDouble(FieldOperand(rax, HeapNumber::kValueOffset), r14);
__ movq(FieldOperand(r11,
__ movp(FieldOperand(r11,
r9,
times_pointer_size,
FixedArray::kHeaderSize),
rax);
__ movq(r15, r9);
__ movp(r15, r9);
__ RecordWriteArray(r11,
rax,
r15,
......@@ -439,7 +439,7 @@ void ElementsTransitionGenerator::GenerateDoubleToObject(
// Replace the-hole NaN with the-hole pointer.
__ bind(&convert_hole);
__ movq(FieldOperand(r11,
__ movp(FieldOperand(r11,
r9,
times_pointer_size,
FixedArray::kHeaderSize),
......@@ -450,7 +450,7 @@ void ElementsTransitionGenerator::GenerateDoubleToObject(
__ j(not_sign, &loop);
// Replace receiver's backing store with newly created and filled FixedArray.
__ movq(FieldOperand(rdx, JSObject::kElementsOffset), r11);
__ movp(FieldOperand(rdx, JSObject::kElementsOffset), r11);
__ RecordWriteField(rdx,
JSObject::kElementsOffset,
r11,
......@@ -459,11 +459,11 @@ void ElementsTransitionGenerator::GenerateDoubleToObject(
EMIT_REMEMBERED_SET,
OMIT_SMI_CHECK);
__ pop(rax);
__ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
__ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
__ bind(&only_change_map);
// Set transitioned map.
__ movq(FieldOperand(rdx, HeapObject::kMapOffset), rbx);
__ movp(FieldOperand(rdx, HeapObject::kMapOffset), rbx);
__ RecordWriteField(rdx,
HeapObject::kMapOffset,
rbx,
......@@ -480,7 +480,7 @@ void StringCharLoadGenerator::Generate(MacroAssembler* masm,
Register result,
Label* call_runtime) {
// Fetch the instance type of the receiver into result register.
__ movq(result, FieldOperand(string, HeapObject::kMapOffset));
__ movp(result, FieldOperand(string, HeapObject::kMapOffset));
__ movzxbl(result, FieldOperand(result, Map::kInstanceTypeOffset));
// We need special handling for indirect strings.
......@@ -497,7 +497,7 @@ void StringCharLoadGenerator::Generate(MacroAssembler* masm,
Label indirect_string_loaded;
__ SmiToInteger32(result, FieldOperand(string, SlicedString::kOffsetOffset));
__ addq(index, result);
__ movq(string, FieldOperand(string, SlicedString::kParentOffset));
__ movp(string, FieldOperand(string, SlicedString::kParentOffset));
__ jmp(&indirect_string_loaded, Label::kNear);
// Handle cons strings.
......@@ -509,10 +509,10 @@ void StringCharLoadGenerator::Generate(MacroAssembler* masm,
__ CompareRoot(FieldOperand(string, ConsString::kSecondOffset),
Heap::kempty_stringRootIndex);
__ j(not_equal, call_runtime);
__ movq(string, FieldOperand(string, ConsString::kFirstOffset));
__ movp(string, FieldOperand(string, ConsString::kFirstOffset));
__ bind(&indirect_string_loaded);
__ movq(result, FieldOperand(string, HeapObject::kMapOffset));
__ movp(result, FieldOperand(string, HeapObject::kMapOffset));
__ movzxbl(result, FieldOperand(result, Map::kInstanceTypeOffset));
// Distinguish sequential and external strings. Only these two string
......@@ -539,7 +539,7 @@ void StringCharLoadGenerator::Generate(MacroAssembler* masm,
// Check encoding.
STATIC_ASSERT(kTwoByteStringTag == 0);
__ testb(result, Immediate(kStringEncodingMask));
__ movq(result, FieldOperand(string, ExternalString::kResourceDataOffset));
__ movp(result, FieldOperand(string, ExternalString::kResourceDataOffset));
__ j(not_equal, &ascii_external, Label::kNear);
// Two-byte string.
__ movzxwl(result, Operand(result, index, times_2, 0));
......@@ -641,7 +641,7 @@ static byte* GetNoCodeAgeSequence(uint32_t* length) {
// FUNCTION and OPTIMIZED_FUNCTION code:
CodePatcher patcher(sequence, kNoCodeAgeSequenceLength);
patcher.masm()->push(rbp);
patcher.masm()->movq(rbp, rsp);
patcher.masm()->movp(rbp, rsp);
patcher.masm()->push(rsi);
patcher.masm()->push(rdi);
initialized = true;
......
src/x64/debug-x64.cc
View file @ de72001f
......@@ -320,7 +320,7 @@ void Debug::GenerateFrameDropperLiveEdit(MacroAssembler* masm) {
ExternalReference(Debug_Address::RestarterFrameFunctionPointer(),
masm->isolate());
__ Move(rax, restarter_frame_function_slot);
__ movq(Operand(rax, 0), Immediate(0));
__ movp(Operand(rax, 0), Immediate(0));
// We do not know our frame height, but set rsp based on rbp.
__ lea(rsp, Operand(rbp, -1 * kPointerSize));
......@@ -329,11 +329,11 @@ void Debug::GenerateFrameDropperLiveEdit(MacroAssembler* masm) {
__ pop(rbp);
// Load context from the function.
__ movq(rsi, FieldOperand(rdi, JSFunction::kContextOffset));
__ movp(rsi, FieldOperand(rdi, JSFunction::kContextOffset));
// Get function code.
__ movq(rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
__ movq(rdx, FieldOperand(rdx, SharedFunctionInfo::kCodeOffset));
__ movp(rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
__ movp(rdx, FieldOperand(rdx, SharedFunctionInfo::kCodeOffset));
__ lea(rdx, FieldOperand(rdx, Code::kHeaderSize));
// Re-run JSFunction, rdi is function, rsi is context.
......
src/x64/deoptimizer-x64.cc
View file @ de72001f
......@@ -165,11 +165,11 @@ void Deoptimizer::EntryGenerator::Generate() {
Register arg5 = r11;
// Get the bailout id from the stack.
__ movq(arg_reg_3, Operand(rsp, kSavedRegistersAreaSize));
__ movp(arg_reg_3, Operand(rsp, kSavedRegistersAreaSize));
// Get the address of the location in the code object
// and compute the fp-to-sp delta in register arg5.
__ movq(arg_reg_4, Operand(rsp, kSavedRegistersAreaSize + 1 * kRegisterSize));
__ movp(arg_reg_4, Operand(rsp, kSavedRegistersAreaSize + 1 * kRegisterSize));
__ lea(arg5, Operand(rsp, kSavedRegistersAreaSize + 1 * kRegisterSize +
kPCOnStackSize));
......@@ -178,19 +178,19 @@ void Deoptimizer::EntryGenerator::Generate() {
// Allocate a new deoptimizer object.
__ PrepareCallCFunction(6);
__ movq(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
__ movq(arg_reg_1, rax);
__ movp(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
__ movp(arg_reg_1, rax);
__ Set(arg_reg_2, type());
// Args 3 and 4 are already in the right registers.
// On windows put the arguments on the stack (PrepareCallCFunction
// has created space for this). On linux pass the arguments in r8 and r9.
#ifdef _WIN64
__ movq(Operand(rsp, 4 * kPointerSize), arg5);
__ movp(Operand(rsp, 4 * kPointerSize), arg5);
__ LoadAddress(arg5, ExternalReference::isolate_address(isolate()));
__ movq(Operand(rsp, 5 * kPointerSize), arg5);
__ movp(Operand(rsp, 5 * kPointerSize), arg5);
#else
__ movq(r8, arg5);
__ movp(r8, arg5);
__ LoadAddress(r9, ExternalReference::isolate_address(isolate()));
#endif
......@@ -199,7 +199,7 @@ void Deoptimizer::EntryGenerator::Generate() {
}
// Preserve deoptimizer object in register rax and get the input
// frame descriptor pointer.
__ movq(rbx, Operand(rax, Deoptimizer::input_offset()));
__ movp(rbx, Operand(rax, Deoptimizer::input_offset()));
// Fill in the input registers.
for (int i = kNumberOfRegisters -1; i >= 0; i--) {
......@@ -219,7 +219,7 @@ void Deoptimizer::EntryGenerator::Generate() {
// Compute a pointer to the unwinding limit in register rcx; that is
// the first stack slot not part of the input frame.
__ movq(rcx, Operand(rbx, FrameDescription::frame_size_offset()));
__ movp(rcx, Operand(rbx, FrameDescription::frame_size_offset()));
__ addq(rcx, rsp);
// Unwind the stack down to - but not including - the unwinding
......@@ -239,7 +239,7 @@ void Deoptimizer::EntryGenerator::Generate() {
// Compute the output frame in the deoptimizer.
__ push(rax);
__ PrepareCallCFunction(2);
__ movq(arg_reg_1, rax);
__ movp(arg_reg_1, rax);
__ LoadAddress(arg_reg_2, ExternalReference::isolate_address(isolate()));
{
AllowExternalCallThatCantCauseGC scope(masm());
......@@ -254,13 +254,13 @@ void Deoptimizer::EntryGenerator::Generate() {
// Outer loop state: rax = current FrameDescription**, rdx = one past the
// last FrameDescription**.
__ movl(rdx, Operand(rax, Deoptimizer::output_count_offset()));
__ movq(rax, Operand(rax, Deoptimizer::output_offset()));
__ movp(rax, Operand(rax, Deoptimizer::output_offset()));
__ lea(rdx, Operand(rax, rdx, times_pointer_size, 0));
__ jmp(&outer_loop_header);
__ bind(&outer_push_loop);
// Inner loop state: rbx = current FrameDescription*, rcx = loop index.
__ movq(rbx, Operand(rax, 0));
__ movq(rcx, Operand(rbx, FrameDescription::frame_size_offset()));
__ movp(rbx, Operand(rax, 0));
__ movp(rcx, Operand(rbx, FrameDescription::frame_size_offset()));
__ jmp(&inner_loop_header);
__ bind(&inner_push_loop);
__ subq(rcx, Immediate(sizeof(intptr_t)));
......
src/x64/full-codegen-x64.cc
View file @ de72001f
This diff is collapsed.
src/x64/ic-x64.cc
View file @ de72001f
This diff is collapsed.
src/x64/lithium-codegen-x64.cc
View file @ de72001f
This diff is collapsed.
src/x64/lithium-gap-resolver-x64.cc
View file @ de72001f
......@@ -172,23 +172,23 @@ void LGapResolver::EmitMove(int index) {
Register src = cgen_->ToRegister(source);
if (destination->IsRegister()) {
Register dst = cgen_->ToRegister(destination);
__ movq(dst, src);
__ movp(dst, src);
} else {
ASSERT(destination->IsStackSlot());
Operand dst = cgen_->ToOperand(destination);
__ movq(dst, src);
__ movp(dst, src);
}
} else if (source->IsStackSlot()) {
Operand src = cgen_->ToOperand(source);
if (destination->IsRegister()) {
Register dst = cgen_->ToRegister(destination);
__ movq(dst, src);
__ movp(dst, src);
} else {
ASSERT(destination->IsStackSlot());
Operand dst = cgen_->ToOperand(destination);
__ movq(kScratchRegister, src);
__ movq(dst, kScratchRegister);
__ movp(kScratchRegister, src);
__ movp(dst, kScratchRegister);
}
} else if (source->IsConstantOperand()) {
......@@ -220,10 +220,10 @@ void LGapResolver::EmitMove(int index) {
} else if (cgen_->IsInteger32Constant(constant_source)) {
// Zero top 32 bits of a 64 bit spill slot that holds a 32 bit untagged
// value.
__ movq(dst, Immediate(cgen_->ToInteger32(constant_source)));
__ movp(dst, Immediate(cgen_->ToInteger32(constant_source)));
} else {
__ Move(kScratchRegister, cgen_->ToHandle(constant_source));
__ movq(dst, kScratchRegister);
__ movp(dst, kScratchRegister);
}
}
......@@ -271,9 +271,9 @@ void LGapResolver::EmitSwap(int index) {
cgen_->ToRegister(source->IsRegister() ? source : destination);
Operand mem =
cgen_->ToOperand(source->IsRegister() ? destination : source);
__ movq(kScratchRegister, mem);
__ movq(mem, reg);
__ movq(reg, kScratchRegister);
__ movp(kScratchRegister, mem);
__ movp(mem, reg);
__ movp(reg, kScratchRegister);
} else if ((source->IsStackSlot() && destination->IsStackSlot()) ||
(source->IsDoubleStackSlot() && destination->IsDoubleStackSlot())) {
......@@ -281,9 +281,9 @@ void LGapResolver::EmitSwap(int index) {
Operand src = cgen_->ToOperand(source);
Operand dst = cgen_->ToOperand(destination);
__ movsd(xmm0, src);
__ movq(kScratchRegister, dst);
__ movp(kScratchRegister, dst);
__ movsd(dst, xmm0);
__ movq(src, kScratchRegister);
__ movp(src, kScratchRegister);
} else if (source->IsDoubleRegister() && destination->IsDoubleRegister()) {
// Swap two double registers.
......
src/x64/macro-assembler-x64.cc
View file @ de72001f
This diff is collapsed.
src/x64/macro-assembler-x64.h
View file @ de72001f
......@@ -721,7 +721,7 @@ class MacroAssembler: public Assembler {
void Move(const Operand& dst, Smi* source) {
Register constant = GetSmiConstant(source);
movq(dst, constant);
movp(dst, constant);
}
void Push(Smi* smi);
......
src/x64/regexp-macro-assembler-x64.cc
View file @ de72001f
This diff is collapsed.
src/x64/stub-cache-x64.cc
View file @ de72001f
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment