Lines Matching refs:scratch
168 Register scratch = ip;
170 LoadU64(scratch, MemOperand(kRootRegister, offset), r0);
172 Jump(scratch);
180 // not preserve scratch registers across calls.
193 Register scratch = temps.Acquire();
194 Move(scratch, reference);
199 MemOperand(scratch, kSystemPointerSize));
200 LoadU64(scratch, MemOperand(scratch, 0));
202 Jump(scratch);
274 // preserve scratch registers across calls.
295 void TurboAssembler::Drop(Register count, Register scratch) {
296 ShiftLeftU64(scratch, count, Operand(kSystemPointerSizeLog2));
297 add(sp, sp, scratch);
312 void TurboAssembler::PushArray(Register array, Register size, Register scratch,
319 ShiftLeftU64(scratch, size, Operand(kSystemPointerSizeLog2));
320 add(scratch, array, scratch);
324 LoadU64WithUpdate(scratch2, MemOperand(scratch, -kSystemPointerSize));
334 subi(scratch, array, Operand(kSystemPointerSize));
337 LoadU64WithUpdate(scratch2, MemOperand(scratch, kSystemPointerSize));
543 const Register& scratch) {
547 LoadU64(destination, field_operand, scratch);
553 const Register& scratch) {
557 LoadU64(destination, field_operand, scratch);
562 Register scratch) {
564 LoadU32(dst, src, scratch);
566 LoadU64(dst, src, scratch);
574 const Register& scratch) {
577 StoreU32(value, dst_field_operand, scratch);
580 StoreU64(value, dst_field_operand, scratch);
632 Register scratch) {
636 LoadU64(destination, field_operand, scratch);
761 // not preserve scratch registers across calls.
772 // Will clobber 4 registers: object, address, scratch, ip. The
802 value, // Used as scratch.
805 value, // Used as scratch.
985 Register scratch, Register shift) {
994 andi(scratch, shift, Operand(0x1F));
995 ShiftLeftU32(dst_high, src_low, scratch);
1000 subfic(scratch, shift, Operand(32));
1002 srw(scratch, src_low, scratch);
1003 orx(dst_high, dst_high, scratch);
1032 Register scratch, Register shift) {
1041 andi(scratch, shift, Operand(0x1F));
1042 srw(dst_low, src_high, scratch);
1047 subfic(scratch, shift, Operand(32));
1049 ShiftLeftU32(scratch, src_high, scratch);
1050 orx(dst_low, dst_low, scratch);
1079 Register scratch, Register shift) {
1087 andi(scratch, shift, Operand(0x1F));
1088 sraw(dst_low, src_high, scratch);
1093 subfic(scratch, shift, Operand(32));
1095 ShiftLeftU32(scratch, src_high, scratch);
1096 orx(dst_low, dst_low, scratch);
1428 void MacroAssembler::StackOverflowCheck(Register num_args, Register scratch,
1433 LoadStackLimit(scratch, StackLimitKind::kRealStackLimit);
1434 // Make scratch the space we have left. The stack might already be overflowed
1435 // here which will cause scratch to become negative.
1436 sub(scratch, sp, scratch);
1439 CmpS64(scratch, r0);
1470 Register scratch = r7;
1471 StackOverflowCheck(expected_parameter_count, scratch, &stack_overflow);
1496 LoadRoot(scratch, RootIndex::kUndefinedValue);
1502 StoreU64WithUpdate(scratch, MemOperand(r8, kSystemPointerSize));
1695 Register scratch = temps.Acquire();
1697 mov(scratch, Operand(lower_limit));
1698 sub(scratch, value, scratch);
1699 cmpli(scratch, Operand(higher_limit - lower_limit));
1701 mov(scratch, Operand(higher_limit));
1702 CmpU64(value, scratch);
1723 Register scratch) {
1725 DCHECK(dst != scratch);
1726 DCHECK(overflow_dst != scratch);
1735 mr(scratch, left); // Preserve left.
1737 xor_(overflow_dst, dst, scratch, xorRC); // Original left.
1738 if (!left_is_right) xor_(scratch, dst, right);
1740 mr(scratch, right); // Preserve right.
1743 if (!left_is_right) xor_(scratch, dst, scratch); // Original right.
1747 if (!left_is_right) xor_(scratch, dst, right);
1749 if (!left_is_right) and_(overflow_dst, scratch, overflow_dst, SetRC);
1755 Register scratch) {
1758 DCHECK(dst != scratch);
1759 DCHECK(overflow_dst != scratch);
1768 AddS64(dst, left, Operand(right), scratch);
1780 Register scratch) {
1782 DCHECK(dst != scratch);
1783 DCHECK(overflow_dst != scratch);
1789 mr(scratch, left); // Preserve left.
1791 xor_(overflow_dst, dst, scratch);
1792 xor_(scratch, scratch, right);
1793 and_(overflow_dst, overflow_dst, scratch, SetRC);
1795 mr(scratch, right); // Preserve right.
1798 xor_(scratch, left, scratch);
1799 and_(overflow_dst, overflow_dst, scratch, SetRC);
1803 xor_(scratch, left, right);
1804 and_(overflow_dst, scratch, overflow_dst, SetRC);
1809 DoubleRegister rhs, DoubleRegister scratch) {
1829 fneg(scratch, lhs);
1830 if (scratch == rhs) {
1831 fadd(dst, scratch, rhs);
1833 fsub(dst, scratch, rhs);
1857 DoubleRegister rhs, DoubleRegister scratch) {
1940 Register scratch = ip;
1945 scratch,
1953 TestIfInt32(scratch, result, r0);
2207 Register scratch) {
2213 LoadMap(scratch, object);
2214 CompareInstanceType(scratch, scratch, ALLOCATION_SITE_TYPE);
2238 Register scratch) {
2247 mr(scratch, sp);
2249 scratch);
2253 StoreU64(scratch,
2266 Register scratch) {
2267 PrepareCallCFunction(num_reg_arguments, 0, scratch);
2323 Register scratch = r8;
2324 Push(scratch);
2325 mflr(scratch);
2346 mtlr(scratch);
2347 Pop(scratch);
2398 Register scratch, // scratch may be same register as object
2401 DCHECK(scratch != r0);
2402 ClearRightImm(scratch, object, Operand(kPageSizeBits));
2403 LoadU64(scratch, MemOperand(scratch, BasicMemoryChunk::kFlagsOffset), r0);
2406 and_(r0, scratch, r0, SetRC);
2436 base::Double value, Register scratch) {
2438 !(scratch == r0 && ConstantPoolAccessIsInOverflow())) {
2441 addis(scratch, kConstantPoolRegister, Operand::Zero());
2442 lfd(result, MemOperand(scratch, 0));
2463 mov(scratch, Operand(litVal.ival));
2464 mtfprd(result, scratch);
2471 mov(scratch, Operand(litVal.ival));
2472 std(scratch, MemOperand(sp));
2474 LoadIntLiteral(scratch, litVal.ival[0]);
2475 stw(scratch, MemOperand(sp, 0));
2476 LoadIntLiteral(scratch, litVal.ival[1]);
2477 stw(scratch, MemOperand(sp, 4));
2485 Register scratch) {
2494 DCHECK(src != scratch);
2497 extsw(scratch, src);
2498 std(scratch, MemOperand(sp, 0));
2500 srawi(scratch, src, 31);
2501 stw(scratch, MemOperand(sp, Register::kExponentOffset));
2510 Register scratch) {
2519 DCHECK(src != scratch);
2522 clrldi(scratch, src, Operand(32));
2523 std(scratch, MemOperand(sp, 0));
2525 li(scratch, Operand::Zero());
2526 stw(scratch, MemOperand(sp, Register::kExponentOffset));
2562 Register scratch) {
2564 ShiftLeftU64(scratch, src_hi, Operand(32));
2565 rldimi(scratch, src_lo, 0, 32);
2566 mtfprd(dst, scratch);
2580 Register scratch) {
2583 mffprd(scratch, dst);
2584 rldimi(scratch, src, 0, 32);
2585 mtfprd(dst, scratch);
2599 Register scratch) {
2602 mffprd(scratch, dst);
2603 rldimi(scratch, src, 32, 0);
2604 mtfprd(dst, scratch);
2673 Register scratch) {
2675 ShiftLeftU64(scratch, src, Operand(32));
2676 mtfprd(dst, scratch);
2688 DoubleRegister scratch) {
2690 xscvdpspn(scratch, src);
2691 mffprwz(dst, scratch);
2707 Register scratch, OEBit s, RCBit r) {
2711 mov(scratch, value);
2712 add(dst, src, scratch, s, r);
2722 Register scratch, OEBit s, RCBit r) {
2726 mov(scratch, value);
2727 sub(dst, src, scratch, s, r);
2738 Register scratch, RCBit r) {
2739 AddS64(dst, src, value, scratch, LeaveOE, r);
2750 Register scratch, RCBit r) {
2751 SubS64(dst, src, value, scratch, LeaveOE, r);
2756 Register scratch, OEBit s, RCBit r) {
2760 mov(scratch, value);
2761 mulld(dst, src, scratch, s, r);
2771 Register scratch, OEBit s, RCBit r) {
2772 MulS64(dst, src, value, scratch, s, r);
2807 Register scratch = GetRegisterThatIsNotOneOf(dst, src, value);
2808 Push(scratch);
2809 divd(scratch, src, value);
2810 mulld(scratch, scratch, value);
2811 sub(dst, src, scratch);
2812 Pop(scratch);
2820 Register scratch = GetRegisterThatIsNotOneOf(dst, src, value);
2821 Push(scratch);
2822 divdu(scratch, src, value);
2823 mulld(scratch, scratch, value);
2824 sub(dst, src, scratch);
2825 Pop(scratch);
2833 Register scratch = GetRegisterThatIsNotOneOf(dst, src, value);
2834 Push(scratch);
2835 divw(scratch, src, value);
2836 mullw(scratch, scratch, value);
2837 sub(dst, src, scratch);
2838 Pop(scratch);
2846 Register scratch = GetRegisterThatIsNotOneOf(dst, src, value);
2847 Push(scratch);
2848 divwu(scratch, src, value);
2849 mullw(scratch, scratch, value);
2850 sub(dst, src, scratch);
2851 Pop(scratch);
2857 Register scratch, RCBit r) {
2861 mov(scratch, value);
2862 and_(dst, src, scratch, r);
2872 Register scratch, RCBit r) {
2876 mov(scratch, value);
2877 orx(dst, src, scratch, r);
2887 Register scratch, RCBit r) {
2891 mov(scratch, value);
2892 xor_(dst, src, scratch, r);
2902 Register scratch, RCBit r) {
2903 AndU64(dst, src, value, scratch, r);
2914 Register scratch, RCBit r) {
2915 OrU64(dst, src, value, scratch, r);
2926 Register scratch, RCBit r) {
2927 XorU64(dst, src, value, scratch, r);
3002 Register scratch, CRegister cr) {
3007 mov(scratch, src2);
3008 CmpS64(src1, scratch, cr);
3013 Register scratch, CRegister cr) {
3018 mov(scratch, src2);
3019 CmpU64(src1, scratch, cr);
3028 Register scratch, CRegister cr) {
3033 mov(scratch, src2);
3034 CmpS32(src1, scratch, cr);
3043 Register scratch, CRegister cr) {
3048 mov(scratch, src2);
3049 cmplw(src1, scratch, cr);
3106 void MacroAssembler::CmpSmiLiteral(Register src1, Smi smi, Register scratch,
3109 CmpS32(src1, Operand(smi), scratch, cr);
3111 LoadSmiLiteral(scratch, smi);
3112 CmpS64(src1, scratch, cr);
3116 void MacroAssembler::CmplSmiLiteral(Register src1, Smi smi, Register scratch,
3119 CmpU64(src1, Operand(smi), scratch, cr);
3121 LoadSmiLiteral(scratch, smi);
3122 CmpU64(src1, scratch, cr);
3127 Register scratch) {
3129 AddS64(dst, src, Operand(smi.ptr()), scratch);
3131 LoadSmiLiteral(scratch, smi);
3132 add(dst, src, scratch);
3137 Register scratch) {
3139 AddS64(dst, src, Operand(-(static_cast<intptr_t>(smi.ptr()))), scratch);
3141 LoadSmiLiteral(scratch, smi);
3142 sub(dst, src, scratch);
3147 Register scratch, RCBit rc) {
3149 AndU64(dst, src, Operand(smi), scratch, rc);
3151 LoadSmiLiteral(scratch, smi);
3152 and_(dst, src, scratch, rc);
3163 CHECK_NE(scratch, no_reg); \
3164 mov(scratch, Operand(offset)); \
3165 rr_op(reg, MemOperand(mem.ra(), scratch)); \
3173 CHECK_NE(scratch, no_reg); \
3174 addi(scratch, mem.rb(), Operand(offset)); \
3175 rr_op(reg, MemOperand(mem.ra(), scratch)); \
3177 CHECK_NE(scratch, no_reg); \
3178 mov(scratch, Operand(offset)); \
3179 add(scratch, scratch, mem.rb()); \
3180 rr_op(reg, MemOperand(mem.ra(), scratch)); \
3193 CHECK_NE(scratch, no_reg); \
3194 mov(scratch, Operand(offset)); \
3195 rr_op(reg, MemOperand(mem.ra(), scratch)); \
3203 CHECK_NE(scratch, no_reg); \
3204 addi(scratch, mem.rb(), Operand(offset)); \
3205 rr_op(reg, MemOperand(mem.ra(), scratch)); \
3207 CHECK_NE(scratch, no_reg); \
3208 mov(scratch, Operand(offset)); \
3209 add(scratch, scratch, mem.rb()); \
3210 rr_op(reg, MemOperand(mem.ra(), scratch)); \
3223 Register scratch) { \
3250 Register scratch) { \
3258 Register scratch) {
3259 LoadU8(dst, mem, scratch);
3282 addi(scratch, mem.rb(), Operand(mem.offset())); \
3284 mov(scratch, Operand(mem.offset())); \
3285 op(reg, MemOperand(mem.ra(), scratch)); \
3287 mov(scratch, Operand(mem.offset())); \
3288 if (mem.rb() != no_reg) add(scratch, scratch, mem.rb()); \
3289 op(reg, MemOperand(mem.ra(), scratch)); \
3304 Register scratch) { \
3310 Register scratch) { \
3311 name(reg, mem, scratch); \
3320 Register scratch) {
3322 LoadU32LE(dst, mem, scratch);
3325 LoadS32(dst, mem, scratch);
3330 Register scratch) {
3332 LoadU16LE(dst, mem, scratch);
3335 LoadS16(dst, mem, scratch);
3340 Register scratch, Register scratch2) {
3342 LoadU64LE(scratch, mem, scratch2);
3343 push(scratch);
3345 pop(scratch);
3347 LoadF64(dst, mem, scratch);
3352 Register scratch, Register scratch2) {
3354 LoadU32LE(scratch, mem, scratch2);
3355 push(scratch);
3357 pop(scratch);
3359 LoadF32(dst, mem, scratch);
3364 Register scratch, Register scratch2) {
3367 LoadU64(scratch, mem, scratch2);
3368 StoreU64LE(scratch, mem, scratch2);
3370 StoreF64(dst, mem, scratch);
3375 Register scratch, Register scratch2) {
3378 LoadU32(scratch, mem, scratch2);
3379 StoreU32LE(scratch, mem, scratch2);
3381 StoreF32(dst, mem, scratch);
3400 void TurboAssembler::SwapP(Register src, Register dst, Register scratch) {
3402 DCHECK(!AreAliased(src, dst, scratch));
3403 mr(scratch, src);
3405 mr(dst, scratch);
3408 void TurboAssembler::SwapP(Register src, MemOperand dst, Register scratch) {
3410 DCHECK(!AreAliased(src, dst.ra(), scratch));
3412 DCHECK(!AreAliased(src, dst.rb(), scratch));
3413 DCHECK(!AreAliased(src, scratch));
3414 mr(scratch, src);
3416 StoreU64(scratch, dst, r0);
3452 DoubleRegister scratch) {
3454 DCHECK(!AreAliased(src, dst, scratch));
3455 fmr(scratch, src);
3457 fmr(dst, scratch);
3461 DoubleRegister scratch) {
3462 DCHECK(!AreAliased(src, scratch));
3463 fmr(scratch, src);
3465 StoreF32(scratch, dst, r0);
3479 DoubleRegister scratch) {
3481 DCHECK(!AreAliased(src, dst, scratch));
3482 fmr(scratch, src);
3484 fmr(dst, scratch);
3488 DoubleRegister scratch) {
3489 DCHECK(!AreAliased(src, scratch));
3490 fmr(scratch, src);
3492 StoreF64(scratch, dst, r0);
3506 Simd128Register scratch) {
3508 vor(scratch, src, src);
3510 vor(dst, scratch, scratch);
3514 Simd128Register scratch) {
3515 DCHECK(src != scratch);
3516 // push v0, to be used as scratch
3529 Simd128Register scratch) {
3530 // push v0 and v1, to be used as scratch
3553 Register scratch) {
3559 rlwinm(scratch, val, 8, 16, 23);
3561 orx(dst, scratch, dst);
3566 Register scratch) {
3572 rotlwi(scratch, val, 8);
3573 rlwimi(scratch, val, 24, 0, 7);
3574 rlwimi(scratch, val, 24, 16, 23);
3575 ZeroExtWord32(dst, scratch);
3651 Register scratch = r11;
3653 DCHECK(!AreAliased(destination, scratch));
3654 DCHECK(!AreAliased(code_object, scratch));
3659 LoadS32(scratch, FieldMemOperand(code_object, Code::kFlagsOffset), r0);
3661 and_(r0, scratch, r0, SetRC);
3672 LoadS32(scratch, FieldMemOperand(code_object, Code::kBuiltinIndexOffset),
3674 ShiftLeftU64(destination, scratch, Operand(kSystemPointerSizeLog2));