MIPS: Fix register confusion in non-VFP3 BinaryOpStubs on ARM
Port r12980 (13380d3b) BUG= TEST= Review URL: https://codereview.chromium.org/11308158 Patch from Akos Palfi <palfia@homejinni.com>. git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@13088 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
jkummerow@chromium.org
parent
d2fbb819a1
commit
bea4580fa8
@ -734,13 +734,13 @@ void FloatingPointHelper::ConvertIntToDouble(MacroAssembler* masm,
|
||||
Register int_scratch,
|
||||
Destination destination,
|
||||
FPURegister double_dst,
|
||||
Register dst1,
|
||||
Register dst2,
|
||||
Register dst_mantissa,
|
||||
Register dst_exponent,
|
||||
Register scratch2,
|
||||
FPURegister single_scratch) {
|
||||
ASSERT(!int_scratch.is(scratch2));
|
||||
ASSERT(!int_scratch.is(dst1));
|
||||
ASSERT(!int_scratch.is(dst2));
|
||||
ASSERT(!int_scratch.is(dst_mantissa));
|
||||
ASSERT(!int_scratch.is(dst_exponent));
|
||||
|
||||
Label done;
|
||||
|
||||
@ -749,64 +749,65 @@ void FloatingPointHelper::ConvertIntToDouble(MacroAssembler* masm,
|
||||
__ mtc1(int_scratch, single_scratch);
|
||||
__ cvt_d_w(double_dst, single_scratch);
|
||||
if (destination == kCoreRegisters) {
|
||||
__ Move(dst1, dst2, double_dst);
|
||||
__ Move(dst_mantissa, dst_exponent, double_dst);
|
||||
}
|
||||
} else {
|
||||
Label fewer_than_20_useful_bits;
|
||||
// Expected output:
|
||||
// | dst2 | dst1 |
|
||||
// | dst_exponent | dst_mantissa |
|
||||
// | s | exp | mantissa |
|
||||
|
||||
// Check for zero.
|
||||
__ mov(dst2, int_scratch);
|
||||
__ mov(dst1, int_scratch);
|
||||
__ mov(dst_exponent, int_scratch);
|
||||
__ mov(dst_mantissa, int_scratch);
|
||||
__ Branch(&done, eq, int_scratch, Operand(zero_reg));
|
||||
|
||||
// Preload the sign of the value.
|
||||
__ And(dst2, int_scratch, Operand(HeapNumber::kSignMask));
|
||||
__ And(dst_exponent, int_scratch, Operand(HeapNumber::kSignMask));
|
||||
// Get the absolute value of the object (as an unsigned integer).
|
||||
Label skip_sub;
|
||||
__ Branch(&skip_sub, ge, dst2, Operand(zero_reg));
|
||||
__ Branch(&skip_sub, ge, dst_exponent, Operand(zero_reg));
|
||||
__ Subu(int_scratch, zero_reg, int_scratch);
|
||||
__ bind(&skip_sub);
|
||||
|
||||
// Get mantissa[51:20].
|
||||
|
||||
// Get the position of the first set bit.
|
||||
__ Clz(dst1, int_scratch);
|
||||
__ Clz(dst_mantissa, int_scratch);
|
||||
__ li(scratch2, 31);
|
||||
__ Subu(dst1, scratch2, dst1);
|
||||
__ Subu(dst_mantissa, scratch2, dst_mantissa);
|
||||
|
||||
// Set the exponent.
|
||||
__ Addu(scratch2, dst1, Operand(HeapNumber::kExponentBias));
|
||||
__ Ins(dst2, scratch2,
|
||||
__ Addu(scratch2, dst_mantissa, Operand(HeapNumber::kExponentBias));
|
||||
__ Ins(dst_exponent, scratch2,
|
||||
HeapNumber::kExponentShift, HeapNumber::kExponentBits);
|
||||
|
||||
// Clear the first non null bit.
|
||||
__ li(scratch2, Operand(1));
|
||||
__ sllv(scratch2, scratch2, dst1);
|
||||
__ sllv(scratch2, scratch2, dst_mantissa);
|
||||
__ li(at, -1);
|
||||
__ Xor(scratch2, scratch2, at);
|
||||
__ And(int_scratch, int_scratch, scratch2);
|
||||
|
||||
// Get the number of bits to set in the lower part of the mantissa.
|
||||
__ Subu(scratch2, dst1, Operand(HeapNumber::kMantissaBitsInTopWord));
|
||||
__ Subu(scratch2, dst_mantissa,
|
||||
Operand(HeapNumber::kMantissaBitsInTopWord));
|
||||
__ Branch(&fewer_than_20_useful_bits, lt, scratch2, Operand(zero_reg));
|
||||
// Set the higher 20 bits of the mantissa.
|
||||
__ srlv(at, int_scratch, scratch2);
|
||||
__ or_(dst2, dst2, at);
|
||||
__ or_(dst_exponent, dst_exponent, at);
|
||||
__ li(at, 32);
|
||||
__ subu(scratch2, at, scratch2);
|
||||
__ sllv(dst1, int_scratch, scratch2);
|
||||
__ sllv(dst_mantissa, int_scratch, scratch2);
|
||||
__ Branch(&done);
|
||||
|
||||
__ bind(&fewer_than_20_useful_bits);
|
||||
__ li(at, HeapNumber::kMantissaBitsInTopWord);
|
||||
__ subu(scratch2, at, dst1);
|
||||
__ subu(scratch2, at, dst_mantissa);
|
||||
__ sllv(scratch2, int_scratch, scratch2);
|
||||
__ Or(dst2, dst2, scratch2);
|
||||
// Set dst1 to 0.
|
||||
__ mov(dst1, zero_reg);
|
||||
__ Or(dst_exponent, dst_exponent, scratch2);
|
||||
// Set dst_mantissa to 0.
|
||||
__ mov(dst_mantissa, zero_reg);
|
||||
}
|
||||
__ bind(&done);
|
||||
}
|
||||
@ -817,8 +818,8 @@ void FloatingPointHelper::LoadNumberAsInt32Double(MacroAssembler* masm,
|
||||
Destination destination,
|
||||
DoubleRegister double_dst,
|
||||
DoubleRegister double_scratch,
|
||||
Register dst1,
|
||||
Register dst2,
|
||||
Register dst_mantissa,
|
||||
Register dst_exponent,
|
||||
Register heap_number_map,
|
||||
Register scratch1,
|
||||
Register scratch2,
|
||||
@ -834,8 +835,8 @@ void FloatingPointHelper::LoadNumberAsInt32Double(MacroAssembler* masm,
|
||||
|
||||
__ JumpIfNotSmi(object, &obj_is_not_smi);
|
||||
__ SmiUntag(scratch1, object);
|
||||
ConvertIntToDouble(masm, scratch1, destination, double_dst, dst1, dst2,
|
||||
scratch2, single_scratch);
|
||||
ConvertIntToDouble(masm, scratch1, destination, double_dst, dst_mantissa,
|
||||
dst_exponent, scratch2, single_scratch);
|
||||
__ Branch(&done);
|
||||
|
||||
__ bind(&obj_is_not_smi);
|
||||
@ -863,27 +864,51 @@ void FloatingPointHelper::LoadNumberAsInt32Double(MacroAssembler* masm,
|
||||
__ Branch(not_int32, ne, except_flag, Operand(zero_reg));
|
||||
|
||||
if (destination == kCoreRegisters) {
|
||||
__ Move(dst1, dst2, double_dst);
|
||||
__ Move(dst_mantissa, dst_exponent, double_dst);
|
||||
}
|
||||
|
||||
} else {
|
||||
ASSERT(!scratch1.is(object) && !scratch2.is(object));
|
||||
// Load the double value in the destination registers.
|
||||
__ lw(dst2, FieldMemOperand(object, HeapNumber::kExponentOffset));
|
||||
__ lw(dst1, FieldMemOperand(object, HeapNumber::kMantissaOffset));
|
||||
bool save_registers = object.is(dst_mantissa) || object.is(dst_exponent);
|
||||
if (save_registers) {
|
||||
// Save both output registers, because the other one probably holds
|
||||
// an important value too.
|
||||
__ Push(dst_exponent, dst_mantissa);
|
||||
}
|
||||
__ lw(dst_exponent, FieldMemOperand(object, HeapNumber::kExponentOffset));
|
||||
__ lw(dst_mantissa, FieldMemOperand(object, HeapNumber::kMantissaOffset));
|
||||
|
||||
// Check for 0 and -0.
|
||||
__ And(scratch1, dst1, Operand(~HeapNumber::kSignMask));
|
||||
__ Or(scratch1, scratch1, Operand(dst2));
|
||||
__ Branch(&done, eq, scratch1, Operand(zero_reg));
|
||||
Label zero;
|
||||
__ And(scratch1, dst_exponent, Operand(~HeapNumber::kSignMask));
|
||||
__ Or(scratch1, scratch1, Operand(dst_mantissa));
|
||||
__ Branch(&zero, eq, scratch1, Operand(zero_reg));
|
||||
|
||||
// Check that the value can be exactly represented by a 32-bit integer.
|
||||
// Jump to not_int32 if that's not the case.
|
||||
DoubleIs32BitInteger(masm, dst1, dst2, scratch1, scratch2, not_int32);
|
||||
Label restore_input_and_miss;
|
||||
DoubleIs32BitInteger(masm, dst_exponent, dst_mantissa, scratch1, scratch2,
|
||||
&restore_input_and_miss);
|
||||
|
||||
// dst1 and dst2 were trashed. Reload the double value.
|
||||
__ lw(dst2, FieldMemOperand(object, HeapNumber::kExponentOffset));
|
||||
__ lw(dst1, FieldMemOperand(object, HeapNumber::kMantissaOffset));
|
||||
// dst_* were trashed. Reload the double value.
|
||||
if (save_registers) {
|
||||
__ Pop(dst_exponent, dst_mantissa);
|
||||
}
|
||||
__ lw(dst_exponent, FieldMemOperand(object, HeapNumber::kExponentOffset));
|
||||
__ lw(dst_mantissa, FieldMemOperand(object, HeapNumber::kMantissaOffset));
|
||||
__ Branch(&done);
|
||||
|
||||
__ bind(&restore_input_and_miss);
|
||||
if (save_registers) {
|
||||
__ Pop(dst_exponent, dst_mantissa);
|
||||
}
|
||||
__ Branch(not_int32);
|
||||
|
||||
__ bind(&zero);
|
||||
if (save_registers) {
|
||||
__ Drop(2);
|
||||
}
|
||||
}
|
||||
|
||||
__ bind(&done);
|
||||
@ -979,14 +1004,14 @@ void FloatingPointHelper::LoadNumberAsInt32(MacroAssembler* masm,
|
||||
|
||||
|
||||
void FloatingPointHelper::DoubleIs32BitInteger(MacroAssembler* masm,
|
||||
Register src1,
|
||||
Register src2,
|
||||
Register src_exponent,
|
||||
Register src_mantissa,
|
||||
Register dst,
|
||||
Register scratch,
|
||||
Label* not_int32) {
|
||||
// Get exponent alone in scratch.
|
||||
__ Ext(scratch,
|
||||
src1,
|
||||
src_exponent,
|
||||
HeapNumber::kExponentShift,
|
||||
HeapNumber::kExponentBits);
|
||||
|
||||
@ -1006,11 +1031,11 @@ void FloatingPointHelper::DoubleIs32BitInteger(MacroAssembler* masm,
|
||||
// Another way to put it is that if (exponent - signbit) > 30 then the
|
||||
// number cannot be represented as an int32.
|
||||
Register tmp = dst;
|
||||
__ srl(at, src1, 31);
|
||||
__ srl(at, src_exponent, 31);
|
||||
__ subu(tmp, scratch, at);
|
||||
__ Branch(not_int32, gt, tmp, Operand(30));
|
||||
// - Bits [21:0] in the mantissa are not null.
|
||||
__ And(tmp, src2, 0x3fffff);
|
||||
__ And(tmp, src_mantissa, 0x3fffff);
|
||||
__ Branch(not_int32, ne, tmp, Operand(zero_reg));
|
||||
|
||||
// Otherwise the exponent needs to be big enough to shift left all the
|
||||
@ -1021,20 +1046,20 @@ void FloatingPointHelper::DoubleIs32BitInteger(MacroAssembler* masm,
|
||||
|
||||
// Get the 32 higher bits of the mantissa in dst.
|
||||
__ Ext(dst,
|
||||
src2,
|
||||
src_mantissa,
|
||||
HeapNumber::kMantissaBitsInTopWord,
|
||||
32 - HeapNumber::kMantissaBitsInTopWord);
|
||||
__ sll(at, src1, HeapNumber::kNonMantissaBitsInTopWord);
|
||||
__ sll(at, src_exponent, HeapNumber::kNonMantissaBitsInTopWord);
|
||||
__ or_(dst, dst, at);
|
||||
|
||||
// Create the mask and test the lower bits (of the higher bits).
|
||||
__ li(at, 32);
|
||||
__ subu(scratch, at, scratch);
|
||||
__ li(src2, 1);
|
||||
__ sllv(src1, src2, scratch);
|
||||
__ Subu(src1, src1, Operand(1));
|
||||
__ And(src1, dst, src1);
|
||||
__ Branch(not_int32, ne, src1, Operand(zero_reg));
|
||||
__ li(src_mantissa, 1);
|
||||
__ sllv(src_exponent, src_mantissa, scratch);
|
||||
__ Subu(src_exponent, src_exponent, Operand(1));
|
||||
__ And(src_exponent, dst, src_exponent);
|
||||
__ Branch(not_int32, ne, src_exponent, Operand(zero_reg));
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -3868,20 +3868,20 @@ void KeyedLoadStubCompiler::GenerateLoadExternalArray(
|
||||
// (a0 is not modified).
|
||||
__ LoadRoot(t1, Heap::kHeapNumberMapRootIndex);
|
||||
__ AllocateHeapNumber(v0, a3, t0, t1, &slow, TAG_RESULT);
|
||||
Register dst1 = t2;
|
||||
Register dst2 = t3;
|
||||
Register dst_mantissa = t2;
|
||||
Register dst_exponent = t3;
|
||||
FloatingPointHelper::Destination dest =
|
||||
FloatingPointHelper::kCoreRegisters;
|
||||
FloatingPointHelper::ConvertIntToDouble(masm,
|
||||
value,
|
||||
dest,
|
||||
f0,
|
||||
dst1,
|
||||
dst2,
|
||||
dst_mantissa,
|
||||
dst_exponent,
|
||||
t1,
|
||||
f2);
|
||||
__ sw(dst1, FieldMemOperand(v0, HeapNumber::kMantissaOffset));
|
||||
__ sw(dst2, FieldMemOperand(v0, HeapNumber::kExponentOffset));
|
||||
__ sw(dst_mantissa, FieldMemOperand(v0, HeapNumber::kMantissaOffset));
|
||||
__ sw(dst_exponent, FieldMemOperand(v0, HeapNumber::kExponentOffset));
|
||||
__ Ret();
|
||||
}
|
||||
} else if (elements_kind == EXTERNAL_UNSIGNED_INT_ELEMENTS) {
|
||||
@ -4180,7 +4180,7 @@ void KeyedStoreStubCompiler::GenerateStoreExternalArray(
|
||||
}
|
||||
FloatingPointHelper::ConvertIntToDouble(
|
||||
masm, t1, destination,
|
||||
f0, t2, t3, // These are: double_dst, dst1, dst2.
|
||||
f0, t2, t3, // These are: double_dst, dst_mantissa, dst_exponent.
|
||||
t0, f2); // These are: scratch2, single_scratch.
|
||||
if (destination == FloatingPointHelper::kFPURegisters) {
|
||||
CpuFeatures::Scope scope(FPU);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user