AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Make the use of xmm0 as double scratch register explicit in ia32 and x64.

Browse Source 
R=svenpanne@chromium.org

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

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16847 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
bmeurer@chromium.org 2013-09-20 06:01:25 +00:00
parent 220c40542b
commit f5b92e94ef
4 changed files with 79 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
src/ia32/lithium-codegen-ia32.cc
View File

@ -1996,9 +1996,10 @@ void LCodeGen::DoConstantD(LConstantD* instr) {
__ movd(res, Operand(temp)); __ movd(res, Operand(temp));
__ psllq(res, 32); __ psllq(res, 32);
if (lower != 0) { if (lower != 0) {
XMMRegister xmm_scratch = double_scratch0();
__ Set(temp, Immediate(lower)); __ Set(temp, Immediate(lower));
__ movd(xmm0, Operand(temp)); __ movd(xmm_scratch, Operand(temp));
__ por(res, xmm0); __ por(res, xmm_scratch);
} }
} }
} }
@ -2207,7 +2208,7 @@ void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
__ jmp(&return_right, Label::kNear); __ jmp(&return_right, Label::kNear);
__ bind(&check_zero); __ bind(&check_zero);
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
__ xorps(xmm_scratch, xmm_scratch); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(left_reg, xmm_scratch); __ ucomisd(left_reg, xmm_scratch);
__ j(not_equal, &return_left, Label::kNear); // left == right != 0. __ j(not_equal, &return_left, Label::kNear); // left == right != 0.
@ -2377,8 +2378,9 @@ void LCodeGen::DoBranch(LBranch* instr) {
ASSERT(!info()->IsStub()); ASSERT(!info()->IsStub());
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
XMMRegister reg = ToDoubleRegister(instr->value()); XMMRegister reg = ToDoubleRegister(instr->value());
__ xorps(xmm0, xmm0); XMMRegister xmm_scratch = double_scratch0();
__ ucomisd(reg, xmm0); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(reg, xmm_scratch);
EmitBranch(instr, not_equal); EmitBranch(instr, not_equal);
} else { } else {
ASSERT(r.IsTagged()); ASSERT(r.IsTagged());
@ -2398,8 +2400,9 @@ void LCodeGen::DoBranch(LBranch* instr) {
} else if (type.IsHeapNumber()) { } else if (type.IsHeapNumber()) {
ASSERT(!info()->IsStub()); ASSERT(!info()->IsStub());
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
__ xorps(xmm0, xmm0); XMMRegister xmm_scratch = double_scratch0();
__ ucomisd(xmm0, FieldOperand(reg, HeapNumber::kValueOffset)); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(xmm_scratch, FieldOperand(reg, HeapNumber::kValueOffset));
EmitBranch(instr, not_equal); EmitBranch(instr, not_equal);
} else if (type.IsString()) { } else if (type.IsString()) {
ASSERT(!info()->IsStub()); ASSERT(!info()->IsStub());
@ -2484,8 +2487,9 @@ void LCodeGen::DoBranch(LBranch* instr) {
__ j(not_equal, &not_heap_number, Label::kNear); __ j(not_equal, &not_heap_number, Label::kNear);
if (CpuFeatures::IsSafeForSnapshot(SSE2)) { if (CpuFeatures::IsSafeForSnapshot(SSE2)) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
__ xorps(xmm0, xmm0); XMMRegister xmm_scratch = double_scratch0();
__ ucomisd(xmm0, FieldOperand(reg, HeapNumber::kValueOffset)); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(xmm_scratch, FieldOperand(reg, HeapNumber::kValueOffset));
} else { } else {
__ fldz(); __ fldz();
__ fld_d(FieldOperand(reg, HeapNumber::kValueOffset)); __ fld_d(FieldOperand(reg, HeapNumber::kValueOffset));
@ -3925,7 +3929,7 @@ void LCodeGen::DoMathAbs(LMathAbs* instr) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
if (r.IsDouble()) { if (r.IsDouble()) {
XMMRegister scratch = xmm0; XMMRegister scratch = double_scratch0();
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
__ xorps(scratch, scratch); __ xorps(scratch, scratch);
__ subsd(scratch, input_reg); __ subsd(scratch, input_reg);
@ -3946,7 +3950,7 @@ void LCodeGen::DoMathAbs(LMathAbs* instr) {
void LCodeGen::DoMathFloor(LMathFloor* instr) { void LCodeGen::DoMathFloor(LMathFloor* instr) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
Register output_reg = ToRegister(instr->result()); Register output_reg = ToRegister(instr->result());
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
@ -4014,7 +4018,7 @@ void LCodeGen::DoMathRound(LMathRound* instr) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
Register output_reg = ToRegister(instr->result()); Register output_reg = ToRegister(instr->result());
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
XMMRegister input_temp = ToDoubleRegister(instr->temp()); XMMRegister input_temp = ToDoubleRegister(instr->temp());
ExternalReference one_half = ExternalReference::address_of_one_half(); ExternalReference one_half = ExternalReference::address_of_one_half();
ExternalReference minus_one_half = ExternalReference minus_one_half =
@ -4081,7 +4085,7 @@ void LCodeGen::DoMathSqrt(LMathSqrt* instr) {
void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) { void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
Register scratch = ToRegister(instr->temp()); Register scratch = ToRegister(instr->temp());
ASSERT(ToDoubleRegister(instr->result()).is(input_reg)); ASSERT(ToDoubleRegister(instr->result()).is(input_reg));
@ -4200,8 +4204,7 @@ void LCodeGen::DoRandom(LRandom* instr) {
// by computing: // by computing:
// ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)). // ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
XMMRegister result = ToDoubleRegister(instr->result()); XMMRegister result = ToDoubleRegister(instr->result());
// We use xmm0 as fixed scratch register here. XMMRegister scratch4 = double_scratch0();
XMMRegister scratch4 = xmm0;
__ mov(scratch3, Immediate(0x49800000)); // 1.0 x 2^20 as single. __ mov(scratch3, Immediate(0x49800000)); // 1.0 x 2^20 as single.
__ movd(scratch4, scratch3); __ movd(scratch4, scratch3);
__ movd(result, random); __ movd(result, random);
@ -4215,9 +4218,10 @@ void LCodeGen::DoMathLog(LMathLog* instr) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
ASSERT(instr->value()->Equals(instr->result())); ASSERT(instr->value()->Equals(instr->result()));
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
XMMRegister xmm_scratch = double_scratch0();
Label positive, done, zero; Label positive, done, zero;
__ xorps(xmm0, xmm0); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(input_reg, xmm0); __ ucomisd(input_reg, xmm_scratch);
__ j(above, &positive, Label::kNear); __ j(above, &positive, Label::kNear);
__ j(equal, &zero, Label::kNear); __ j(equal, &zero, Label::kNear);
ExternalReference nan = ExternalReference nan =
@ -4247,10 +4251,11 @@ void LCodeGen::DoMathExp(LMathExp* instr) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
XMMRegister input = ToDoubleRegister(instr->value()); XMMRegister input = ToDoubleRegister(instr->value());
XMMRegister result = ToDoubleRegister(instr->result()); XMMRegister result = ToDoubleRegister(instr->result());
XMMRegister temp0 = double_scratch0();
Register temp1 = ToRegister(instr->temp1()); Register temp1 = ToRegister(instr->temp1());
Register temp2 = ToRegister(instr->temp2()); Register temp2 = ToRegister(instr->temp2());
MathExpGenerator::EmitMathExp(masm(), input, result, xmm0, temp1, temp2); MathExpGenerator::EmitMathExp(masm(), input, result, temp0, temp1, temp2);
} }
@ -4631,8 +4636,9 @@ void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) { if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) {
if (CpuFeatures::IsSafeForSnapshot(SSE2)) { if (CpuFeatures::IsSafeForSnapshot(SSE2)) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
__ cvtsd2ss(xmm0, ToDoubleRegister(instr->value())); XMMRegister xmm_scratch = double_scratch0();
__ movss(operand, xmm0); __ cvtsd2ss(xmm_scratch, ToDoubleRegister(instr->value()));
__ movss(operand, xmm_scratch);
} else { } else {
__ fld(0); __ fld(0);
__ fstp_s(operand); __ fstp_s(operand);
@ -5095,6 +5101,7 @@ void LCodeGen::DoDeferredNumberTagI(LInstruction* instr,
Label slow; Label slow;
Register reg = ToRegister(value); Register reg = ToRegister(value);
Register tmp = reg.is(eax) ? ecx : eax; Register tmp = reg.is(eax) ? ecx : eax;
XMMRegister xmm_scratch = double_scratch0();
// Preserve the value of all registers. // Preserve the value of all registers.
PushSafepointRegistersScope scope(this); PushSafepointRegistersScope scope(this);
@ -5109,7 +5116,7 @@ void LCodeGen::DoDeferredNumberTagI(LInstruction* instr,
__ xor_(reg, 0x80000000); __ xor_(reg, 0x80000000);
if (CpuFeatures::IsSupported(SSE2)) { if (CpuFeatures::IsSupported(SSE2)) {
CpuFeatureScope feature_scope(masm(), SSE2); CpuFeatureScope feature_scope(masm(), SSE2);
__ Cvtsi2sd(xmm0, Operand(reg)); __ Cvtsi2sd(xmm_scratch, Operand(reg));
} else { } else {
__ push(reg); __ push(reg);
__ fild_s(Operand(esp, 0)); __ fild_s(Operand(esp, 0));
@ -5118,7 +5125,7 @@ void LCodeGen::DoDeferredNumberTagI(LInstruction* instr,
} else { } else {
if (CpuFeatures::IsSupported(SSE2)) { if (CpuFeatures::IsSupported(SSE2)) {
CpuFeatureScope feature_scope(masm(), SSE2); CpuFeatureScope feature_scope(masm(), SSE2);
__ LoadUint32(xmm0, reg, __ LoadUint32(xmm_scratch, reg,
ToDoubleRegister(LNumberTagU::cast(instr)->temp())); ToDoubleRegister(LNumberTagU::cast(instr)->temp()));
} else { } else {
// There's no fild variant for unsigned values, so zero-extend to a 64-bit // There's no fild variant for unsigned values, so zero-extend to a 64-bit
@ -5154,12 +5161,12 @@ void LCodeGen::DoDeferredNumberTagI(LInstruction* instr,
instr->pointer_map(), 0, Safepoint::kNoLazyDeopt); instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
if (!reg.is(eax)) __ mov(reg, eax); if (!reg.is(eax)) __ mov(reg, eax);
// Done. Put the value in xmm0 into the value of the allocated heap // Done. Put the value in xmm_scratch into the value of the allocated heap
// number. // number.
__ bind(&done); __ bind(&done);
if (CpuFeatures::IsSupported(SSE2)) { if (CpuFeatures::IsSupported(SSE2)) {
CpuFeatureScope feature_scope(masm(), SSE2); CpuFeatureScope feature_scope(masm(), SSE2);
__ movdbl(FieldOperand(reg, HeapNumber::kValueOffset), xmm0); __ movdbl(FieldOperand(reg, HeapNumber::kValueOffset), xmm_scratch);
} else { } else {
__ fstp_d(FieldOperand(reg, HeapNumber::kValueOffset)); __ fstp_d(FieldOperand(reg, HeapNumber::kValueOffset));
} }
@ -5349,7 +5356,7 @@ void LCodeGen::EmitNumberUntagD(Register input_reg,
__ movdbl(result_reg, FieldOperand(input_reg, HeapNumber::kValueOffset)); __ movdbl(result_reg, FieldOperand(input_reg, HeapNumber::kValueOffset));
if (deoptimize_on_minus_zero) { if (deoptimize_on_minus_zero) {
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
__ xorps(xmm_scratch, xmm_scratch); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(result_reg, xmm_scratch); __ ucomisd(result_reg, xmm_scratch);
__ j(not_zero, &done, Label::kNear); __ j(not_zero, &done, Label::kNear);
@ -5515,7 +5522,8 @@ void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
if (CpuFeatures::IsSafeForSnapshot(SSE2)) { if (CpuFeatures::IsSafeForSnapshot(SSE2)) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
XMMRegister input_reg = ToDoubleRegister(input); XMMRegister input_reg = ToDoubleRegister(input);
__ DoubleToI(result_reg, input_reg, xmm0, XMMRegister xmm_scratch = double_scratch0();
__ DoubleToI(result_reg, input_reg, xmm_scratch,
instr->hydrogen()->GetMinusZeroMode(), &bailout, Label::kNear); instr->hydrogen()->GetMinusZeroMode(), &bailout, Label::kNear);
} else { } else {
X87Register input_reg = ToX87Register(input); X87Register input_reg = ToX87Register(input);
@ -5542,7 +5550,8 @@ void LCodeGen::DoDoubleToSmi(LDoubleToSmi* instr) {
if (CpuFeatures::IsSafeForSnapshot(SSE2)) { if (CpuFeatures::IsSafeForSnapshot(SSE2)) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
XMMRegister input_reg = ToDoubleRegister(input); XMMRegister input_reg = ToDoubleRegister(input);
__ DoubleToI(result_reg, input_reg, xmm0, XMMRegister xmm_scratch = double_scratch0();
__ DoubleToI(result_reg, input_reg, xmm_scratch,
instr->hydrogen()->GetMinusZeroMode(), &bailout, Label::kNear); instr->hydrogen()->GetMinusZeroMode(), &bailout, Label::kNear);
} else { } else {
X87Register input_reg = ToX87Register(input); X87Register input_reg = ToX87Register(input);
@ -5706,8 +5715,9 @@ void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) { void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
CpuFeatureScope scope(masm(), SSE2); CpuFeatureScope scope(masm(), SSE2);
XMMRegister value_reg = ToDoubleRegister(instr->unclamped()); XMMRegister value_reg = ToDoubleRegister(instr->unclamped());
XMMRegister xmm_scratch = double_scratch0();
Register result_reg = ToRegister(instr->result()); Register result_reg = ToRegister(instr->result());
__ ClampDoubleToUint8(value_reg, xmm0, result_reg); __ ClampDoubleToUint8(value_reg, xmm_scratch, result_reg);
} }
@ -5723,6 +5733,7 @@ void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
ASSERT(instr->unclamped()->Equals(instr->result())); ASSERT(instr->unclamped()->Equals(instr->result()));
Register input_reg = ToRegister(instr->unclamped()); Register input_reg = ToRegister(instr->unclamped());
XMMRegister xmm_scratch = double_scratch0();
Label is_smi, done, heap_number; Label is_smi, done, heap_number;
__ JumpIfSmi(input_reg, &is_smi); __ JumpIfSmi(input_reg, &is_smi);
@ -5741,8 +5752,8 @@ void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
// Heap number // Heap number
__ bind(&heap_number); __ bind(&heap_number);
__ movdbl(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset)); __ movdbl(xmm_scratch, FieldOperand(input_reg, HeapNumber::kValueOffset));
__ ClampDoubleToUint8(xmm0, xmm1, input_reg); __ ClampDoubleToUint8(xmm_scratch, xmm1, input_reg);
__ jmp(&done, Label::kNear); __ jmp(&done, Label::kNear);
// smi // smi

2
src/ia32/lithium-codegen-ia32.h
View File

@ -208,6 +208,8 @@ class LCodeGen V8_FINAL BASE_EMBEDDED {
Scope* scope() const { return scope_; } Scope* scope() const { return scope_; }
HGraph* graph() const { return chunk()->graph(); } HGraph* graph() const { return chunk()->graph(); }
XMMRegister double_scratch0() const { return xmm0; }
int GetNextEmittedBlock() const; int GetNextEmittedBlock() const;
void EmitClassOfTest(Label* if_true, void EmitClassOfTest(Label* if_true,

58
src/x64/lithium-codegen-x64.cc
View File

@ -1832,7 +1832,7 @@ void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
__ jmp(&return_right, Label::kNear); __ jmp(&return_right, Label::kNear);
__ bind(&check_zero); __ bind(&check_zero);
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
__ xorps(xmm_scratch, xmm_scratch); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(left_reg, xmm_scratch); __ ucomisd(left_reg, xmm_scratch);
__ j(not_equal, &return_left, Label::kNear); // left == right != 0. __ j(not_equal, &return_left, Label::kNear); // left == right != 0.
@ -1878,15 +1878,17 @@ void LCodeGen::DoArithmeticD(LArithmeticD* instr) {
// when there is a mulsd depending on the result // when there is a mulsd depending on the result
__ movaps(left, left); __ movaps(left, left);
break; break;
case Token::MOD: case Token::MOD: {
XMMRegister xmm_scratch = double_scratch0();
__ PrepareCallCFunction(2); __ PrepareCallCFunction(2);
__ movaps(xmm0, left); __ movaps(xmm_scratch, left);
ASSERT(right.is(xmm1)); ASSERT(right.is(xmm1));
__ CallCFunction( __ CallCFunction(
ExternalReference::double_fp_operation(Token::MOD, isolate()), 2); ExternalReference::double_fp_operation(Token::MOD, isolate()), 2);
__ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset)); __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
__ movaps(result, xmm0); __ movaps(result, xmm_scratch);
break; break;
}
default: default:
UNREACHABLE(); UNREACHABLE();
break; break;
@ -1962,8 +1964,9 @@ void LCodeGen::DoBranch(LBranch* instr) {
} else if (r.IsDouble()) { } else if (r.IsDouble()) {
ASSERT(!info()->IsStub()); ASSERT(!info()->IsStub());
XMMRegister reg = ToDoubleRegister(instr->value()); XMMRegister reg = ToDoubleRegister(instr->value());
__ xorps(xmm0, xmm0); XMMRegister xmm_scratch = double_scratch0();
__ ucomisd(reg, xmm0); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(reg, xmm_scratch);
EmitBranch(instr, not_equal); EmitBranch(instr, not_equal);
} else { } else {
ASSERT(r.IsTagged()); ASSERT(r.IsTagged());
@ -1982,8 +1985,9 @@ void LCodeGen::DoBranch(LBranch* instr) {
EmitBranch(instr, no_condition); EmitBranch(instr, no_condition);
} else if (type.IsHeapNumber()) { } else if (type.IsHeapNumber()) {
ASSERT(!info()->IsStub()); ASSERT(!info()->IsStub());
__ xorps(xmm0, xmm0); XMMRegister xmm_scratch = double_scratch0();
__ ucomisd(xmm0, FieldOperand(reg, HeapNumber::kValueOffset)); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(xmm_scratch, FieldOperand(reg, HeapNumber::kValueOffset));
EmitBranch(instr, not_equal); EmitBranch(instr, not_equal);
} else if (type.IsString()) { } else if (type.IsString()) {
ASSERT(!info()->IsStub()); ASSERT(!info()->IsStub());
@ -2064,8 +2068,9 @@ void LCodeGen::DoBranch(LBranch* instr) {
Label not_heap_number; Label not_heap_number;
__ CompareRoot(map, Heap::kHeapNumberMapRootIndex); __ CompareRoot(map, Heap::kHeapNumberMapRootIndex);
__ j(not_equal, &not_heap_number, Label::kNear); __ j(not_equal, &not_heap_number, Label::kNear);
__ xorps(xmm0, xmm0); XMMRegister xmm_scratch = double_scratch0();
__ ucomisd(xmm0, FieldOperand(reg, HeapNumber::kValueOffset)); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(xmm_scratch, FieldOperand(reg, HeapNumber::kValueOffset));
__ j(zero, instr->FalseLabel(chunk_)); __ j(zero, instr->FalseLabel(chunk_));
__ jmp(instr->TrueLabel(chunk_)); __ jmp(instr->TrueLabel(chunk_));
__ bind(&not_heap_number); __ bind(&not_heap_number);
@ -3447,7 +3452,7 @@ void LCodeGen::DoMathAbs(LMathAbs* instr) {
Representation r = instr->hydrogen()->value()->representation(); Representation r = instr->hydrogen()->value()->representation();
if (r.IsDouble()) { if (r.IsDouble()) {
XMMRegister scratch = xmm0; XMMRegister scratch = double_scratch0();
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
__ xorps(scratch, scratch); __ xorps(scratch, scratch);
__ subsd(scratch, input_reg); __ subsd(scratch, input_reg);
@ -3469,7 +3474,7 @@ void LCodeGen::DoMathAbs(LMathAbs* instr) {
void LCodeGen::DoMathFloor(LMathFloor* instr) { void LCodeGen::DoMathFloor(LMathFloor* instr) {
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
Register output_reg = ToRegister(instr->result()); Register output_reg = ToRegister(instr->result());
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
@ -3528,7 +3533,7 @@ void LCodeGen::DoMathFloor(LMathFloor* instr) {
void LCodeGen::DoMathRound(LMathRound* instr) { void LCodeGen::DoMathRound(LMathRound* instr) {
const XMMRegister xmm_scratch = xmm0; const XMMRegister xmm_scratch = double_scratch0();
Register output_reg = ToRegister(instr->result()); Register output_reg = ToRegister(instr->result());
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
static int64_t one_half = V8_INT64_C(0x3FE0000000000000); // 0.5 static int64_t one_half = V8_INT64_C(0x3FE0000000000000); // 0.5
@ -3596,7 +3601,7 @@ void LCodeGen::DoMathSqrt(LMathSqrt* instr) {
void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) { void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) {
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
XMMRegister input_reg = ToDoubleRegister(instr->value()); XMMRegister input_reg = ToDoubleRegister(instr->value());
ASSERT(ToDoubleRegister(instr->result()).is(input_reg)); ASSERT(ToDoubleRegister(instr->result()).is(input_reg));
@ -3713,8 +3718,7 @@ void LCodeGen::DoRandom(LRandom* instr) {
// by computing: // by computing:
// ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)). // ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
XMMRegister result = ToDoubleRegister(instr->result()); XMMRegister result = ToDoubleRegister(instr->result());
// We use xmm0 as fixed scratch register here. XMMRegister scratch4 = double_scratch0();
XMMRegister scratch4 = xmm0;
__ movq(scratch3, V8_INT64_C(0x4130000000000000), __ movq(scratch3, V8_INT64_C(0x4130000000000000),
RelocInfo::NONE64); // 1.0 x 2^20 as double RelocInfo::NONE64); // 1.0 x 2^20 as double
__ movq(scratch4, scratch3); __ movq(scratch4, scratch3);
@ -3727,10 +3731,11 @@ void LCodeGen::DoRandom(LRandom* instr) {
void LCodeGen::DoMathExp(LMathExp* instr) { void LCodeGen::DoMathExp(LMathExp* instr) {
XMMRegister input = ToDoubleRegister(instr->value()); XMMRegister input = ToDoubleRegister(instr->value());
XMMRegister result = ToDoubleRegister(instr->result()); XMMRegister result = ToDoubleRegister(instr->result());
XMMRegister temp0 = double_scratch0();
Register temp1 = ToRegister(instr->temp1()); Register temp1 = ToRegister(instr->temp1());
Register temp2 = ToRegister(instr->temp2()); Register temp2 = ToRegister(instr->temp2());
MathExpGenerator::EmitMathExp(masm(), input, result, xmm0, temp1, temp2); MathExpGenerator::EmitMathExp(masm(), input, result, temp0, temp1, temp2);
} }
@ -4531,7 +4536,8 @@ void LCodeGen::DoDeferredNumberTagU(LNumberTagU* instr) {
// Load value into xmm1 which will be preserved across potential call to // Load value into xmm1 which will be preserved across potential call to
// runtime (MacroAssembler::EnterExitFrameEpilogue preserves only allocatable // runtime (MacroAssembler::EnterExitFrameEpilogue preserves only allocatable
// XMM registers on x64). // XMM registers on x64).
__ LoadUint32(xmm1, reg, xmm0); XMMRegister xmm_scratch = double_scratch0();
__ LoadUint32(xmm1, reg, xmm_scratch);
if (FLAG_inline_new) { if (FLAG_inline_new) {
__ AllocateHeapNumber(reg, tmp, &slow); __ AllocateHeapNumber(reg, tmp, &slow);
@ -4650,7 +4656,7 @@ void LCodeGen::EmitNumberUntagD(Register input_reg,
} }
if (deoptimize_on_minus_zero) { if (deoptimize_on_minus_zero) {
XMMRegister xmm_scratch = xmm0; XMMRegister xmm_scratch = double_scratch0();
__ xorps(xmm_scratch, xmm_scratch); __ xorps(xmm_scratch, xmm_scratch);
__ ucomisd(xmm_scratch, result_reg); __ ucomisd(xmm_scratch, result_reg);
__ j(not_equal, &done, Label::kNear); __ j(not_equal, &done, Label::kNear);
@ -4778,7 +4784,8 @@ void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
__ TruncateDoubleToI(result_reg, input_reg); __ TruncateDoubleToI(result_reg, input_reg);
} else { } else {
Label bailout, done; Label bailout, done;
__ DoubleToI(result_reg, input_reg, xmm0, XMMRegister xmm_scratch = double_scratch0();
__ DoubleToI(result_reg, input_reg, xmm_scratch,
instr->hydrogen()->GetMinusZeroMode(), &bailout, Label::kNear); instr->hydrogen()->GetMinusZeroMode(), &bailout, Label::kNear);
__ jmp(&done, Label::kNear); __ jmp(&done, Label::kNear);
@ -4799,7 +4806,8 @@ void LCodeGen::DoDoubleToSmi(LDoubleToSmi* instr) {
Register result_reg = ToRegister(result); Register result_reg = ToRegister(result);
Label bailout, done; Label bailout, done;
__ DoubleToI(result_reg, input_reg, xmm0, XMMRegister xmm_scratch = double_scratch0();
__ DoubleToI(result_reg, input_reg, xmm_scratch,
instr->hydrogen()->GetMinusZeroMode(), &bailout, Label::kNear); instr->hydrogen()->GetMinusZeroMode(), &bailout, Label::kNear);
__ jmp(&done, Label::kNear); __ jmp(&done, Label::kNear);
@ -4945,8 +4953,9 @@ void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) { void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
XMMRegister value_reg = ToDoubleRegister(instr->unclamped()); XMMRegister value_reg = ToDoubleRegister(instr->unclamped());
XMMRegister xmm_scratch = double_scratch0();
Register result_reg = ToRegister(instr->result()); Register result_reg = ToRegister(instr->result());
__ ClampDoubleToUint8(value_reg, xmm0, result_reg); __ ClampDoubleToUint8(value_reg, xmm_scratch, result_reg);
} }
@ -4961,6 +4970,7 @@ void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
ASSERT(instr->unclamped()->Equals(instr->result())); ASSERT(instr->unclamped()->Equals(instr->result()));
Register input_reg = ToRegister(instr->unclamped()); Register input_reg = ToRegister(instr->unclamped());
XMMRegister temp_xmm_reg = ToDoubleRegister(instr->temp_xmm()); XMMRegister temp_xmm_reg = ToDoubleRegister(instr->temp_xmm());
XMMRegister xmm_scratch = double_scratch0();
Label is_smi, done, heap_number; Label is_smi, done, heap_number;
__ JumpIfSmi(input_reg, &is_smi); __ JumpIfSmi(input_reg, &is_smi);
@ -4979,8 +4989,8 @@ void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
// Heap number // Heap number
__ bind(&heap_number); __ bind(&heap_number);
__ movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset)); __ movsd(xmm_scratch, FieldOperand(input_reg, HeapNumber::kValueOffset));
__ ClampDoubleToUint8(xmm0, temp_xmm_reg, input_reg); __ ClampDoubleToUint8(xmm_scratch, temp_xmm_reg, input_reg);
__ jmp(&done, Label::kNear); __ jmp(&done, Label::kNear);
// smi // smi

2
src/x64/lithium-codegen-x64.h
View File

@ -166,6 +166,8 @@ class LCodeGen V8_FINAL BASE_EMBEDDED {
Scope* scope() const { return scope_; } Scope* scope() const { return scope_; }
HGraph* graph() const { return chunk()->graph(); } HGraph* graph() const { return chunk()->graph(); }
XMMRegister double_scratch0() const { return xmm0; }
int GetNextEmittedBlock() const; int GetNextEmittedBlock() const;
void EmitClassOfTest(Label* if_true, void EmitClassOfTest(Label* if_true,