Lines Matching refs:HeapNumber
471 STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u);
472 __ and_(exponent, source_, Operand(HeapNumber::kSignMask), SetCC);
484 HeapNumber::kExponentBias << HeapNumber::kExponentShift;
496 // divide the constant 31 + HeapNumber::kExponentBias, 0x41d, into two parts
499 __ rsb(mantissa, zeros_, Operand(31 + HeapNumber::kExponentBias - fudge));
503 Operand(mantissa, LSL, HeapNumber::kExponentShift));
509 __ mov(mantissa, Operand(source_, LSL, HeapNumber::kMantissaBitsInTopWord));
513 Operand(source_, LSR, 32 - HeapNumber::kMantissaBitsInTopWord));
595 // Load the double from tagged HeapNumber to double register.
597 __ vldr(dst, scratch1, HeapNumber::kValueOffset);
601 __ Ldrd(dst1, dst2, FieldMemOperand(object, HeapNumber::kValueOffset));
648 __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kMapOffset));
660 __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kExponentOffset));
661 __ ldr(scratch2, FieldMemOperand(object, HeapNumber::kMantissaOffset));
705 __ and_(dst2, int_scratch, Operand(HeapNumber::kSignMask), SetCC);
716 __ add(scratch2, dst1, Operand(HeapNumber::kExponentBias));
718 HeapNumber::kExponentShift, HeapNumber::kExponentBits);
724 __ cmp(dst1, Operand(HeapNumber::kMantissaBitsInTopWord));
726 __ sub(scratch2, dst1, Operand(HeapNumber::kMantissaBitsInTopWord), SetCC);
735 __ rsb(scratch2, dst1, Operand(HeapNumber::kMantissaBitsInTopWord));
783 __ vldr(double_dst, scratch1, HeapNumber::kValueOffset);
802 __ Ldrd(dst1, dst2, FieldMemOperand(object, HeapNumber::kValueOffset));
805 __ bic(scratch1, dst1, Operand(HeapNumber::kSignMask));
815 __ Ldrd(dst1, dst2, FieldMemOperand(object, HeapNumber::kValueOffset));
855 __ vldr(double_scratch, scratch1, HeapNumber::kValueOffset);
871 __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kExponentOffset));
872 __ ldr(scratch2, FieldMemOperand(object, HeapNumber::kMantissaOffset));
875 __ bic(dst, scratch1, Operand(HeapNumber::kSignMask));
892 __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kExponentOffset));
893 __ tst(scratch1, Operand(HeapNumber::kSignMask));
910 HeapNumber::kExponentShift,
911 HeapNumber::kExponentBits);
914 __ sub(scratch, scratch, Operand(HeapNumber::kExponentBias), SetCC);
945 HeapNumber::kMantissaBitsInTopWord,
946 32 - HeapNumber::kMantissaBitsInTopWord);
949 Operand(src1, LSL, HeapNumber::kNonMantissaBitsInTopWord));
995 FieldMemOperand(heap_number_result, HeapNumber::kValueOffset));
998 HeapNumber::kValueOffset));
1035 STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u);
1041 (HeapNumber::kExponentBias + 30) << HeapNumber::kExponentShift;
1044 __ orr(scratch_, scratch_, Operand(HeapNumber::kSignMask), LeaveCC, cs);
1051 ASSERT(((1 << HeapNumber::kExponentShift) & non_smi_exponent) != 0);
1052 const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2;
1055 HeapNumber::kExponentOffset));
1058 HeapNumber::kMantissaOffset));
1066 non_smi_exponent += 1 << HeapNumber::kExponentShift;
1067 __ mov(ip, Operand(HeapNumber::kSignMask | non_smi_exponent));
1068 __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset));
1070 __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset));
1148 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
1150 __ Sbfx(r3, r2, HeapNumber::kExponentShift, HeapNumber::kExponentBits);
1156 __ mov(r2, Operand(r2, LSL, HeapNumber::kNonMantissaBitsInTopWord));
1158 __ ldr(r3, FieldMemOperand(r0, HeapNumber::kMantissaOffset));
1216 // Load the double from rhs, tagged HeapNumber r0, to d6.
1218 __ vldr(d6, r7, HeapNumber::kValueOffset);
1226 __ Ldrd(r0, r1, FieldMemOperand(rhs, HeapNumber::kValueOffset));
1254 // Load the double from lhs, tagged HeapNumber r1, to d7.
1256 __ vldr(d7, r7, HeapNumber::kValueOffset);
1262 __ Ldrd(r2, r3, FieldMemOperand(lhs, HeapNumber::kValueOffset));
1274 bool exp_first = (HeapNumber::kExponentOffset == HeapNumber::kValueOffset);
1283 HeapNumber::kExponentShift,
1284 HeapNumber::kExponentBits);
1289 Operand(lhs_exponent, LSL, HeapNumber::kNonMantissaBitsInTopWord),
1298 HeapNumber::kExponentShift,
1299 HeapNumber::kExponentBits);
1304 Operand(rhs_exponent, LSL, HeapNumber::kNonMantissaBitsInTopWord),
1327 bool exp_first = (HeapNumber::kExponentOffset == HeapNumber::kValueOffset);
1443 __ vldr(d6, r7, HeapNumber::kValueOffset);
1445 __ vldr(d7, r7, HeapNumber::kValueOffset);
1447 __ Ldrd(r2, r3, FieldMemOperand(lhs, HeapNumber::kValueOffset));
1448 __ Ldrd(r0, r1, FieldMemOperand(rhs, HeapNumber::kValueOffset));
1541 Operand(HeapNumber::kValueOffset - kHeapObjectTag));
1557 __ vldr(d0, scratch2, HeapNumber::kValueOffset);
1559 __ vldr(d1, probe, HeapNumber::kValueOffset);
1642 // be strictly equal if the other is a HeapNumber.
1839 __ vldr(d1, FieldMemOperand(tos_, HeapNumber::kValueOffset));
2068 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
2069 __ eor(r2, r2, Operand(HeapNumber::kSignMask)); // Flip sign.
2070 __ str(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
2086 __ ldr(r3, FieldMemOperand(r0, HeapNumber::kMantissaOffset));
2087 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
2088 __ str(r3, FieldMemOperand(r1, HeapNumber::kMantissaOffset));
2089 __ eor(r2, r2, Operand(HeapNumber::kSignMask)); // Flip sign.
2090 __ str(r2, FieldMemOperand(r1, HeapNumber::kExponentOffset));
2149 __ vstr(d0, r2, HeapNumber::kValueOffset);
2491 __ vstr(d5, r0, HeapNumber::kValueOffset);
2611 __ vstr(d0, r3, HeapNumber::kValueOffset);
2837 __ tst(scratch2, Operand(HeapNumber::kSignMask));
2862 __ vstr(d5, r0, HeapNumber::kValueOffset);
3008 __ vstr(double_scratch, r0, HeapNumber::kValueOffset);
3237 // Check if input is a HeapNumber.
3243 // Input is a HeapNumber. Load it to a double register and store the
3245 __ vldr(d0, FieldMemOperand(r0, HeapNumber::kValueOffset));
3311 __ vldr(d2, FieldMemOperand(r6, HeapNumber::kValueOffset));
3345 __ vstr(d2, FieldMemOperand(r6, HeapNumber::kValueOffset));
3354 __ vstr(d2, FieldMemOperand(r0, HeapNumber::kValueOffset));
3360 __ vldr(d2, FieldMemOperand(r0, HeapNumber::kValueOffset));
3375 // Allocate an aligned object larger than a HeapNumber.
3376 ASSERT(4 * kPointerSize >= HeapNumber::kSize);
3452 const Register heapnumber = r0;
3477 __ vldr(double_base, FieldMemOperand(base, HeapNumber::kValueOffset));
3491 FieldMemOperand(exponent, HeapNumber::kValueOffset));
3497 FieldMemOperand(exponent, HeapNumber::kValueOffset));
3620 heapnumber, scratch, scratch2, heapnumbermap, &call_runtime);
3622 FieldMemOperand(heapnumber, HeapNumber::kValueOffset));
3623 ASSERT(heapnumber.is(r0));
6580 __ vldr(d0, r2, HeapNumber::kValueOffset);
6582 __ vldr(d1, r2, HeapNumber::kValueOffset);
