Lines Matching full:heapnumber
320 STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u);
321 __ and_(exponent, source_, Operand(HeapNumber::kSignMask), SetCC);
333 HeapNumber::kExponentBias << HeapNumber::kExponentShift;
345 // divide the constant 31 + HeapNumber::kExponentBias, 0x41d, into two parts
348 __ rsb(mantissa, zeros_, Operand(31 + HeapNumber::kExponentBias - fudge));
352 Operand(mantissa, LSL, HeapNumber::kExponentShift));
358 __ mov(mantissa, Operand(source_, LSL, HeapNumber::kMantissaBitsInTopWord));
362 Operand(source_, LSR, 32 - HeapNumber::kMantissaBitsInTopWord));
572 // Load the double from tagged HeapNumber to double register.
574 __ vldr(dst, scratch1, HeapNumber::kValueOffset);
578 __ Ldrd(dst1, dst2, FieldMemOperand(object, HeapNumber::kValueOffset));
627 __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kMapOffset));
639 __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kExponentOffset));
640 __ ldr(scratch2, FieldMemOperand(object, HeapNumber::kMantissaOffset));
695 __ and_(dst2, scratch1, Operand(HeapNumber::kSignMask), SetCC);
706 __ add(scratch2, dst1, Operand(HeapNumber::kExponentBias));
708 HeapNumber::kExponentShift, HeapNumber::kExponentBits);
714 __ cmp(dst1, Operand(HeapNumber::kMantissaBitsInTopWord));
716 __ sub(scratch2, dst1, Operand(HeapNumber::kMantissaBitsInTopWord), SetCC);
725 __ rsb(scratch2, dst1, Operand(HeapNumber::kMantissaBitsInTopWord));
747 __ vldr(double_dst, scratch1, HeapNumber::kValueOffset);
766 __ Ldrd(dst1, dst2, FieldMemOperand(object, HeapNumber::kValueOffset));
769 __ bic(scratch1, dst1, Operand(HeapNumber::kSignMask));
779 __ Ldrd(dst1, dst2, FieldMemOperand(object, HeapNumber::kValueOffset));
822 __ vldr(double_scratch, scratch1, HeapNumber::kValueOffset);
838 __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kExponentOffset));
839 __ ldr(scratch2, FieldMemOperand(object, HeapNumber
842 __ bic(dst, scratch1, Operand(HeapNumber::kSignMask));
859 __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kExponentOffset));
860 __ tst(scratch1, Operand(HeapNumber::kSignMask));
877 HeapNumber::kExponentShift,
878 HeapNumber::kExponentBits);
881 __ sub(scratch, scratch, Operand(HeapNumber::kExponentBias), SetCC);
912 HeapNumber::kMantissaBitsInTopWord,
913 32 - HeapNumber::kMantissaBitsInTopWord);
916 Operand(src1, LSL, HeapNumber::kNonMantissaBitsInTopWord));
953 HeapNumber::kValueOffset));
966 STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u);
972 (HeapNumber::kExponentBias + 30) << HeapNumber::kExponentShift;
975 __ orr(scratch_, scratch_, Operand(HeapNumber::kSignMask), LeaveCC, cs);
982 ASSERT(((1 << HeapNumber::kExponentShift) & non_smi_exponent) != 0);
983 const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2;
986 HeapNumber::kExponentOffset));
989 HeapNumber::kMantissaOffset));
997 non_smi_exponent += 1 << HeapNumber::kExponentShift;
998 __ mov(ip, Operand(HeapNumber::kSignMask | non_smi_exponent));
999 __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset));
1001 __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset));
1079 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
1081 __ Sbfx(r3, r2, HeapNumber::kExponentShift, HeapNumber::kExponentBits);
1087 __ mov(r2, Operand(r2, LSL, HeapNumber::kNonMantissaBitsInTopWord));
1089 __ ldr(r3, FieldMemOperand(r0, HeapNumber::kMantissaOffset));
1148 // Load the double from rhs, tagged HeapNumber r0, to d6.
1150 __ vldr(d6, r7, HeapNumber::kValueOffset);
1158 __ Ldrd(r0, r1, FieldMemOperand(rhs, HeapNumber::kValueOffset));
1186 // Load the double from lhs, tagged HeapNumber r1, to d7.
1188 __ vldr(d7, r7, HeapNumber::kValueOffset);
1194 __ Ldrd(r2, r3, FieldMemOperand(lhs, HeapNumber::kValueOffset));
1206 bool exp_first = (HeapNumber::kExponentOffset == HeapNumber::kValueOffset);
1215 HeapNumber::kExponentShift,
1216 HeapNumber::kExponentBits);
1221 Operand(lhs_exponent, LSL, HeapNumber::kNonMantissaBitsInTopWord),
1230 HeapNumber::kExponentShift,
1231 HeapNumber::kExponentBits);
1236 Operand(rhs_exponent, LSL, HeapNumber::kNonMantissaBitsInTopWord),
1259 bool exp_first = (HeapNumber::kExponentOffset == HeapNumber::kValueOffset);
1367 __ vldr(d6, r7, HeapNumber::kValueOffset);
1369 __ vldr(d7, r7, HeapNumber::kValueOffset);
1371 __ Ldrd(r2, r3, FieldMemOperand(lhs, HeapNumber::kValueOffset));
1372 __ Ldrd(r0, r1, FieldMemOperand(rhs, HeapNumber::kValueOffset));
1465 Operand(HeapNumber::kValueOffset - kHeapObjectTag));
1481 __ vldr(d0, scratch2, HeapNumber::kValueOffset);
1483 __ vldr(d1, probe, HeapNumber::kValueOffset);
1567 // be strictly equal if the other is a HeapNumber.
1708 // HeapNumber => false iff +0, -0, or NaN.
1715 __ vldr(d1, ip, HeapNumber::kValueOffset);
2056 __ vstr(d5, r0, HeapNumber::kValueOffset);
2176 __ vstr(d0, r3, HeapNumber::kValueOffset);
2374 __ tst(scratch2, Operand(HeapNumber::kSignMask));
2397 __ vstr(d5, r0, HeapNumber::kValueOffset);
2542 __ vstr(double_scratch, r0, HeapNumber::kValueOffset);
2769 // Check if input is a HeapNumber.
2775 // Input is a HeapNumber. Load it to a double register and store the
2777 __ vldr(d0, FieldMemOperand(r0, HeapNumber::kValueOffset));
2841 __ vldr(d2, FieldMemOperand(r6, HeapNumber::kValueOffset));
2873 __ vstr(d2, FieldMemOperand(r6, HeapNumber::kValueOffset));
2882 __ vstr(d2, FieldMemOperand(r0, HeapNumber::kValueOffset));
2887 __ vldr(d2, FieldMemOperand(r0, HeapNumber::kValueOffset));
2901 // Allocate an aligned object larger than a HeapNumber.
2902 ASSERT(4 * kPointerSize >= HeapNumber::kSize);
2999 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
3000 __ eor(r2, r2, Operand(HeapNumber::kSignMask)); // Flip sign.
3001 __ str(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
3004 __ ldr(r3, FieldMemOperand(r0, HeapNumber::kMantissaOffset));
3005 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
3006 __ str(r3, FieldMemOperand(r1, HeapNumber::kMantissaOffset));
3007 __ eor(r2, r2, Operand(HeapNumber::kSignMask)); // Flip sign.
3008 __ str(r2, FieldMemOperand(r1, HeapNumber::kExponentOffset));
3058 __ vstr(d0, r2, HeapNumber::kValueOffset);
3103 const Register heapnumber = r6;
3127 // Base is a heapnumber. Load it into double register.
3128 __ vldr(double_base, FieldMemOperand(base, HeapNumber::kValueOffset));
3138 __ AllocateHeapNumber(heapnumber,
3152 FieldMemOperand(heapnumber, HeapNumber::kValueOffset));
3153 __ mov(r0, heapnumber);
3160 // Exponent is a heapnumber. Load it into double register.
3162 FieldMemOperand(exponent, HeapNumber::kValueOffset));
3168 __ AllocateHeapNumber(heapnumber,
3182 FieldMemOperand(heapnumber, HeapNumber::kValueOffset));
3183 __ mov(r0, heapnumber);
5785 __ vldr(d0, r2, HeapNumber::kValueOffset);
5787 __ vldr(d1, r2, HeapNumber::kValueOffset);
