Lines Matching refs:value
139 // Clobbers object, dst, value, and ra, if (ra_status == kRAHasBeenSaved)
143 Register value, RAStatus ra_status,
147 DCHECK(!AreAliased(object, value));
154 JumpIfSmi(value, &done);
165 DCHECK(!AreAliased(object, value, scratch));
173 RecordWrite(object, Operand(offset - kHeapObjectTag), value, ra_status,
267 // Clobbers object, address, value, and ra, if (ra_status == kRAHasBeenSaved)
271 Register value, RAStatus ra_status,
275 DCHECK(!AreAliased(object, value));
280 DCHECK(!AreAliased(object, value, temp));
284 Operand(value));
299 JumpIfSmi(value, &done);
305 CheckPageFlag(value,
324 DCHECK(!AreAliased(object, slot_address, value));
1251 void TurboAssembler::AlignedStoreHelper(Reg_T value, const MemOperand& rs,
1258 // make sure scratch does not overwrite value
1259 if (std::is_same<Reg_T, Register>::value)
1260 DCHECK(scratch.code() != value.code());
1264 generator(value, source);
1359 auto fn = [this](Register value, const MemOperand& source) {
1360 this->sb(value, source.rm(), source.offset());
1380 auto fn = [this](Register value, const MemOperand& source) {
1381 this->sh(value, source.rm(), source.offset());
1411 auto fn = [this](Register value, const MemOperand& source) {
1412 if (FLAG_riscv_c_extension && ((value.code() & 0b11000) == 0b01000) &&
1415 this->c_sw(value, source.rm(), source.offset());
1418 this->c_swsp(value, source.offset());
1420 this->sw(value, source.rm(), source.offset());
1444 auto fn = [this](Register value, const MemOperand& source) {
1445 if (FLAG_riscv_c_extension && ((value.code() & 0b11000) == 0b01000) &&
1448 this->c_sd(value, source.rm(), source.offset());
1451 this->c_sdsp(value, source.offset());
1453 this->sd(value, source.rm(), source.offset());
1467 auto fn = [this](FPURegister value, const MemOperand& source) {
1468 this->fsw(value, source.rm(), source.offset());
1490 auto fn = [this](FPURegister value, const MemOperand& source) {
1491 if (FLAG_riscv_c_extension && ((value.code() & 0b11000) == 0b01000) &&
1494 this->c_fsd(value, source.rm(), source.offset());
1497 this->c_fsdsp(value, source.offset());
1499 this->fsd(value, source.rm(), source.offset());
1553 void TurboAssembler::li(Register dst, Handle<HeapObject> value,
1557 // embedding the relocatable value.
1559 IndirectLoadConstant(dst, value);
1562 EmbeddedObjectIndex index = AddEmbeddedObject(value);
1567 li(dst, Operand(value.address(), rmode));
1571 void TurboAssembler::li(Register dst, ExternalReference value, LiFlags mode) {
1574 // embedding the relocatable value.
1576 IndirectLoadExternalReference(dst, value);
1579 li(dst, Operand(value), mode);
1587 static inline int InstrCountForLiLower32Bit(int64_t value) {
1588 int64_t Hi20 = ((value + 0x800) >> 12);
1589 int64_t Lo12 = value << 52 >> 52;
1596 int TurboAssembler::InstrCountForLi64Bit(int64_t value) {
1597 if (is_int32(value + 0x800)) {
1598 return InstrCountForLiLower32Bit(value);
1600 return li_estimate(value);
1624 // Record a value into constant pool.
1647 // this code to load another value which may need all 6 instructions.
1809 // Convert rs to a FP value in fd.
1814 // Convert rs to a FP value in fd.
1819 // Convert rs to a FP value in fd.
1824 // Convert rs to a FP value in fd.
1829 // Convert rs to a FP value in fd.
1834 // Convert rs to a FP value in fd.
1985 // round out-of-range values to the nearest max or min value), therefore special
1994 DCHECK((std::is_same<float, F>::value) || (std::is_same<double, F>::value));
2009 // extract exponent value of the source floating-point to scratch
2010 if (std::is_same<F, double>::value) {
2022 if (std::is_same<F, double>::value) {
2039 if (std::is_same<F, double>::value) {
2052 // kFloat32MantissaBits, it means the floating-point value has no fractional
2054 // Infinity in floating-point representation sets maximal exponent value, so
2057 // (Infinity), so NaN and Infinity are considered rounded value too.
2071 // Since only input whose real exponent value is less than kMantissaBits
2072 // (i.e., 23 or 52-bits) falls into this path, the value range of the input
2078 if (std::is_same<F, double>::value) {
2093 if (std::is_same<F, double>::value) {
2105 // round out-of-range values to the nearest max or min value), therefore special
2110 VU.set(scratch, std::is_same<F, float>::value ? E32 : E64, m1);
2116 // kFloat32MantissaBits, it means the floating-point value has no fractional
2118 // Infinity in floating-point representation sets maximal exponent value, so
2121 // (Infinity), so NaN and Infinity are considered rounded value too.
2695 // uint32_t value = 0x01010101; // (T)~(T)0/255
2701 Register value = temps.Acquire();
2702 DCHECK((rd != value) && (rs != value));
2703 li(value, 0x01010101); // value = 0x01010101;
2718 Mul32(scratch2, value, scratch2); // B2 = 0x0F0F0F0F;
2720 Mul32(rd, rd, value);
2730 // uint64_t value = 0x0101010101010101l; // (T)~(T)0/255
2737 Register value = temps.Acquire();
2738 DCHECK((rd != value) && (rs != value));
2739 li(value, 0x1111111111111111l); // value = 0x1111111111111111l;
2741 Mul64(scratch2, value, scratch2); // B0 = 0x5555555555555555l;
2746 Mul64(scratch2, value, scratch2); // B1 = 0x3333333333333333l;
2754 li(value, 0x0101010101010101l); // value = 0x0101010101010101l;
2755 Mul64(scratch2, value, scratch2); // B2 = 0x0F0F0F0F0F0F0F0Fl;
2757 Mul64(rd, rd, value);
3295 void MacroAssembler::JumpIfIsInRange(Register value, unsigned lower_limit,
3301 Sub64(scratch, value, Operand(lower_limit));
3305 Branch(on_in_range, Uless_equal, value,
3434 // Adjust the value in ra to point to the correct return location, one
3639 Move(dst, fa0); // Reg fa0 is FP return value.
3643 Move(dst, fa0); // Reg fa0 is FP first argument value.
3717 // to push undefined value as arguments.
4141 // All parameters are on the stack. a0 has the return value after call.
4180 // Record a value into constant pool.
4200 void MacroAssembler::EmitIncrementCounter(StatsCounter* counter, int value,
4203 DCHECK_GT(value, 0);
4211 Add32(scratch1, scratch1, Operand(value));
4216 void MacroAssembler::EmitDecrementCounter(StatsCounter* counter, int value,
4219 DCHECK_GT(value, 0);
4227 Sub32(scratch1, scratch1, Operand(value));
4293 // generated instructions is 10, so we use this as a maximum value.
4419 // (used by DirectCEntry to hold the return value if a struct is
4428 // Set the exit frame sp value to point just before the return address
4558 void TurboAssembler::JumpIfSmi(Register value, Label* smi_label) {
4563 andi(scratch, value, kSmiTagMask);
4567 void MacroAssembler::JumpIfNotSmi(Register value, Label* not_smi_label) {
4572 andi(scratch, value, kSmiTagMask);
4711 DCHECK((std::is_same<F_TYPE, float>::value) ||
4712 (std::is_same<F_TYPE, double>::value));
4715 if (std::is_same<float, F_TYPE>::value) {
4731 if (std::is_same<float, F_TYPE>::value) {
4739 if (std::is_same<float, F_TYPE>::value) {
4745 if (std::is_same<float, F_TYPE>::value) {
4755 if (std::is_same<float, F_TYPE>::value) {
4819 // original value of sp.
5086 void TurboAssembler::StoreTaggedField(const Register& value,
5089 Sw(value, dst_field_operand);
5091 Sd(value, dst_field_operand);