Lines Matching refs:scratch
158 Register scratch,
162 And(scratch, object, Operand(ExternalReference::new_space_mask(isolate())));
163 Branch(branch, cc, scratch,
256 map, // Used as scratch.
296 // Will clobber 4 registers: object, address, scratch, ip. The
333 value, // Used as scratch.
339 value, // Used as scratch.
373 Register scratch,
379 JumpIfNotInNewSpace(object, scratch, &ok);
387 ld(scratch, MemOperand(t8));
389 sd(address, MemOperand(scratch));
390 Daddu(scratch, scratch, kPointerSize);
392 sd(scratch, MemOperand(t8));
395 And(t8, scratch, Operand(StoreBuffer::kStoreBufferOverflowBit));
396 DCHECK(!scratch.is(t8));
419 Register scratch,
423 DCHECK(!holder_reg.is(scratch));
425 DCHECK(!scratch.is(at));
428 ld(scratch, MemOperand(fp, StandardFrameConstants::kContextOffset));
432 scratch, Operand(zero_reg));
438 ld(scratch, FieldMemOperand(scratch, offset));
439 ld(scratch, FieldMemOperand(scratch, GlobalObject::kNativeContextOffset));
445 ld(holder_reg, FieldMemOperand(scratch, HeapObject::kMapOffset));
454 Branch(&same_contexts, eq, scratch, Operand(at));
480 ld(scratch, FieldMemOperand(scratch, token_offset));
482 Branch(miss, ne, scratch, Operand(at));
491 void MacroAssembler::GetNumberHash(Register reg0, Register scratch) {
492 // First of all we assign the hash seed to scratch.
493 LoadRoot(scratch, Heap::kHashSeedRootIndex);
494 SmiUntag(scratch);
497 xor_(reg0, reg0, scratch);
504 nor(scratch, reg0, zero_reg);
506 addu(reg0, scratch, at);
521 sll(scratch, reg0, 11);
524 addu(reg0, reg0, scratch);
553 // Scratch registers:
1061 void MacroAssembler::Uld(Register rd, const MemOperand& rs, Register scratch) {
1067 lw(scratch, MemOperand(rs.rm(), rs.offset() + kPointerSize / 2));
1068 dsll32(scratch, scratch, 0);
1069 Daddu(rd, rd, scratch);
1075 void MacroAssembler::Usd(Register rd, const MemOperand& rs, Register scratch) {
1081 dsrl32(scratch, rd, 0);
1082 sw(scratch, MemOperand(rs.rm(), rs.offset() + kPointerSize / 2));
1297 FPURegister scratch) {
1300 Cvt_d_uw(fd, t8, scratch);
1306 FPURegister scratch) {
1311 DCHECK(!fd.is(scratch));
1334 mtc1(zero_reg, scratch);
1335 mthc1(at, scratch);
1337 add_d(fd, fd, scratch);
1365 FPURegister scratch) {
1378 FPURegister scratch) {
1379 Trunc_uw_d(fs, t8, scratch);
1406 FPURegister scratch) {
1407 DCHECK(!fd.is(scratch));
1410 // Load 2^31 into scratch as its float representation.
1412 mtc1(zero_reg, scratch);
1413 mthc1(at, scratch);
1414 // Test if scratch > fd.
1417 BranchF(&simple_convert, NULL, lt, fd, scratch);
1421 sub_d(scratch, fd, scratch);
1422 trunc_w_d(scratch, scratch);
1423 mfc1(rs, scratch);
1430 trunc_w_d(scratch, fd);
1431 mfc1(rs, scratch);
1438 FPURegister ft, FPURegister scratch) {
1443 DCHECK(!fr.is(scratch) && !fs.is(scratch) && !ft.is(scratch));
1444 mul_d(scratch, fs, ft);
1445 add_d(fd, fr, scratch);
1645 Register scratch,
1649 DCHECK(!result.is(scratch));
1651 DCHECK(!except_flag.is(scratch));
1672 cfc1(scratch, FCSR);
1695 ctc1(scratch, FCSR);
1710 Register scratch = at;
1720 cfc1(scratch, FCSR);
1723 And(scratch,
1724 scratch,
1727 Branch(done, eq, scratch, Operand(zero_reg));
1779 Register scratch,
1785 JumpIfNotHeapNumber(object, heap_number_map, scratch, not_number);
1906 Register scratch = at;
1928 slt(scratch, r2, rs);
1929 bne(scratch, zero_reg, offset);
1936 slt(scratch, rs, r2);
1937 beq(scratch, zero_reg, offset);
1944 slt(scratch, rs, r2);
1945 bne(scratch, zero_reg, offset);
1952 slt(scratch, r2, rs);
1953 beq(scratch, zero_reg, offset);
1961 sltu(scratch, r2, rs);
1962 bne(scratch, zero_reg, offset);
1969 sltu(scratch, rs, r2);
1970 beq(scratch, zero_reg, offset);
1978 sltu(scratch, rs, r2);
1979 bne(scratch, zero_reg, offset);
1986 sltu(scratch, r2, rs);
1987 beq(scratch, zero_reg, offset);
2003 // We don't want any other register but scratch clobbered.
2004 DCHECK(!scratch.is(rs));
2005 r2 = scratch;
2010 // We don't want any other register but scratch clobbered.
2011 DCHECK(!scratch.is(rs));
2012 r2 = scratch;
2021 r2 = scratch;
2023 slt(scratch, r2, rs);
2024 bne(scratch, zero_reg, offset);
2031 slti(scratch, rs, rt.imm64_);
2032 beq(scratch, zero_reg, offset);
2034 r2 = scratch;
2036 slt(scratch, rs, r2);
2037 beq(scratch, zero_reg, offset);
2044 slti(scratch, rs, rt.imm64_);
2045 bne(scratch, zero_reg, offset);
2047 r2 = scratch;
2049 slt(scratch, rs, r2);
2050 bne(scratch, zero_reg, offset);
2057 r2 = scratch;
2059 slt(scratch, r2, rs);
2060 beq(scratch, zero_reg, offset);
2068 r2 = scratch;
2070 sltu(scratch, r2, rs);
2071 bne(scratch, zero_reg, offset);
2078 sltiu(scratch, rs, rt.imm64_);
2079 beq(scratch, zero_reg, offset);
2081 r2 = scratch;
2083 sltu(scratch, rs, r2);
2084 beq(scratch, zero_reg, offset);
2092 sltiu(scratch, rs, rt.imm64_);
2093 bne(scratch, zero_reg, offset);
2095 r2 = scratch;
2097 sltu(scratch, rs, r2);
2098 bne(scratch, zero_reg, offset);
2105 r2 = scratch;
2107 sltu(scratch, r2, rs);
2108 beq(scratch, zero_reg, offset);
2140 Register scratch = at;
2166 slt(scratch, r2, rs);
2168 bne(scratch, zero_reg, offset);
2176 slt(scratch, rs, r2);
2178 beq(scratch, zero_reg, offset);
2186 slt(scratch, rs, r2);
2188 bne(scratch, zero_reg, offset);
2196 slt(scratch, r2, rs);
2198 beq(scratch, zero_reg, offset);
2207 sltu(scratch, r2, rs);
2209 bne(scratch, zero_reg, offset);
2217 sltu(scratch, rs, r2);
2219 beq(scratch, zero_reg, offset);
2227 sltu(scratch, rs, r2);
2229 bne(scratch, zero_reg, offset);
2237 sltu(scratch, r2, rs);
2239 beq(scratch, zero_reg, offset);
2256 DCHECK(!scratch.is(rs));
2257 r2 = scratch;
2263 DCHECK(!scratch.is(rs));
2264 r2 = scratch;
2275 DCHECK(!scratch.is(rs));
2276 r2 = scratch;
2278 slt(scratch, r2, rs);
2280 bne(scratch, zero_reg, offset);
2288 slti(scratch, rs, rt.imm64_);
2290 beq(scratch, zero_reg, offset);
2292 DCHECK(!scratch.is(rs));
2293 r2 = scratch;
2295 slt(scratch, rs, r2);
2297 beq(scratch, zero_reg, offset);
2305 slti(scratch, rs, rt.imm64_);
2307 bne(scratch, zero_reg, offset);
2309 DCHECK(!scratch.is(rs));
2310 r2 = scratch;
2312 slt(scratch, rs, r2);
2314 bne(scratch, zero_reg, offset);
2322 DCHECK(!scratch.is(rs));
2323 r2 = scratch;
2325 slt(scratch, r2, rs);
2327 beq(scratch, zero_reg, offset);
2336 DCHECK(!scratch.is(rs));
2337 r2 = scratch;
2339 sltu(scratch, r2, rs);
2341 bne(scratch, zero_reg, offset);
2349 sltiu(scratch, rs, rt.imm64_);
2351 beq(scratch, zero_reg, offset);
2353 DCHECK(!scratch.is(rs));
2354 r2 = scratch;
2356 sltu(scratch, rs, r2);
2358 beq(scratch, zero_reg, offset);
2366 sltiu(scratch, rs, rt.imm64_);
2368 bne(scratch, zero_reg, offset);
2370 DCHECK(!scratch.is(rs));
2371 r2 = scratch;
2373 sltu(scratch, rs, r2);
2375 bne(scratch, zero_reg, offset);
2383 DCHECK(!scratch.is(rs));
2384 scratch;
2386 sltu(scratch, r2, rs);
2388 beq(scratch, zero_reg, offset);
2477 Register scratch = at;
2482 r2 = scratch;
2506 slt(scratch, r2, rs);
2507 beq(scratch, zero_reg, 2);
2513 slt(scratch, rs, r2);
2514 bne(scratch, zero_reg, 2);
2520 slt(scratch, rs, r2);
2521 bne(scratch, zero_reg, 2);
2527 slt(scratch, r2, rs);
2528 bne(scratch, zero_reg, 2);
2537 sltu(scratch, r2, rs);
2538 beq(scratch, zero_reg, 2);
2544 sltu(scratch, rs, r2);
2545 bne(scratch, zero_reg, 2);
2551 sltu(scratch, rs, r2);
2552 bne(scratch, zero_reg, 2);
2558 sltu(scratch, r2, rs);
2559 bne(scratch, zero_reg, 2);
2589 Register scratch = at;
2593 r2 = scratch;
2620 slt(scratch, r2, rs);
2621 beq(scratch, zero_reg, 2);
2628 slt(scratch, rs, r2);
2629 bne(scratch, zero_reg, 2);
2636 slt(scratch, rs, r2);
2637 bne(scratch, zero_reg, 2);
2644 slt(scratch, r2, rs);
2645 bne(scratch, zero_reg, 2);
2655 sltu(scratch, r2, rs);
2656 beq(scratch, zero_reg, 2);
2663 sltu(scratch, rs, r2);
2664 bne(scratch, zero_reg, 2);
2671 sltu(scratch, rs, r2);
2672 bne(scratch, zero_reg, 2);
2679 sltu(scratch, r2, rs);
2680 bne(scratch, zero_reg, 2);
2983 Register scratch) {
2984 if (scratch.is(no_reg)) {
2989 mov(scratch, reg1);
2991 mov(reg2, scratch);
3007 scratch) {
3008 DCHECK(!src.is(scratch));
3009 mov(scratch, src);
3013 dsll32(scratch, scratch, 0);
3014 push(scratch);
3018 void MacroAssembler::PopRegisterAsTwoSmis(Register dst, Register scratch) {
3019 DCHECK(!dst.is(scratch));
3020 pop(scratch);
3021 dsrl32(scratch, scratch, 0);
3025 or_(dst, dst, scratch);
3359 Register scratch) {
3367 li(scratch, Operand(new_space_allocation_top));
3368 ld(scratch, MemOperand(scratch));
3370 object, Operand(scratch));
3373 li(scratch, Operand(new_space_allocation_top));
3374 sd(object, MemOperand(scratch));
3575 Register scratch) {
3581 And(scratch, src, kPointerSize - 1);
3582 Branch(&word_loop, eq, scratch, Operand(zero_reg));
3583 lbu(scratch, MemOperand(src));
3585 sb(scratch, MemOperand(dst));
3593 And(scratch, src, kPointerSize - 1);
3595 scratch, Operand(zero_reg));
3598 ld(scratch, MemOperand(src));
3603 sb(scratch, MemOperand(dst, 0));
3604 dsrl(scratch, scratch, 8);
3605 sb(scratch, MemOperand(dst, 1));
3606 dsrl(scratch, scratch, 8);
3607 sb(scratch, MemOperand(dst, 2));
3608 dsrl(scratch, scratch, 8);
3609 sb(scratch, MemOperand(dst, 3));
3610 dsrl(scratch, scratch, 8);
3611 sb(scratch, MemOperand(dst, 4));
3612 dsrl(scratch, scratch, 8);
3613 sb(scratch, MemOperand(dst, 5));
3614 dsrl(scratch, scratch, 8);
3615 sb(scratch, MemOperand(dst, 6));
3616 dsrl(scratch, scratch, 8);
3617 sb(scratch, MemOperand(dst, 7));
3627 lbu(scratch, MemOperand(src));
3629 sb(scratch, MemOperand(dst));
3651 Register scratch,
3657 lbu(scratch, FieldMemOperand(map, Map::kBitField2Offset));
3658 Branch(fail, hi, scratch,
3664 Register scratch,
3670 lbu(scratch, FieldMemOperand(map, Map::kBitField2Offset));
3671 Branch(fail, ls, scratch,
3673 Branch(fail, hi, scratch,
3679 Register scratch,
3683 lbu(scratch, FieldMemOperand(map, Map::kBitField2Offset));
3684 Branch(fail, hi, scratch,
3761 Register scratch,
3766 ld(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
3767 CompareMapAndBranch(scratch, map, early_success, cond, branch_to);
3781 Register scratch,
3789 CompareMapAndBranch(obj, scratch, map, &success, ne, fail);
3795 Register scratch,
3803 ld(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
3804 Jump(success, RelocInfo::CODE_TARGET, eq, scratch, Operand(map));
3810 Register scratch,
3817 ld(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
3819 Branch(fail, ne, scratch, Operand(at));
4042 Register scratch,
4045 IsInstanceJSObjectType(map, scratch, fail);
4050 Register scratch,
4052 lbu(scratch, FieldMemOperand(map, Map::kInstanceTypeOffset));
4053 Branch(fail, lt, scratch, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
4054 Branch(fail, gt, scratch, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
4059 Register scratch,
4063 ld(scratch, FieldMemOperand(object, HeapObject::kMapOffset));
4064 lbu(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
4065 And(scratch, scratch, Operand(kIsNotStringMask));
4066 Branch(fail, ne, scratch, Operand(zero_reg));
4071 Register scratch,
4073 ld(scratch, FieldMemOperand(object, HeapObject::kMapOffset));
4074 lbu(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
4075 Branch(fail, hi, scratch, Operand(LAST_NAME_TYPE));
4085 Register scratch,
4094 GetObjectType(function, result, scratch);
4095 Branch(miss, ne, scratch, Operand(JS_FUNCTION_TYPE));
4097 ld(scratch,
4099 lwu(scratch,
4100 FieldMemOperand(scratch, SharedFunctionInfo::kCompilerHintsOffset));
4101 And(scratch, scratch,
4103 Branch(miss, ne, scratch, Operand(zero_reg));
4106 lbu(scratch, FieldMemOperand(result, Map::kBitFieldOffset));
4107 And(scratch, scratch, Operand(1 << Map::kHasNonInstancePrototype));
4108 Branch(&non_instance, ne, scratch, Operand(zero_reg));
4123 GetObjectType(result, scratch, scratch);
4124 Branch(&done, ne, scratch, Operand(MAP_TYPE));
4374 Register scratch) {
4376 DCHECK(!dst.is(scratch));
4377 DCHECK(!overflow_dst.is(scratch));
4383 DCHECK(!scratch.is(t9));
4392 mov(scratch, left); // Preserve left.
4394 xor_(scratch, dst, scratch); // Original left.
4396 and_(overflow_dst, overflow_dst, scratch);
4398 mov(scratch, right); // Preserve right.
4400 xor_(scratch, dst, scratch); // Original right.
4402 and_(overflow_dst, overflow_dst, scratch);
4406 xor_(scratch, dst, right);
4407 and_(overflow_dst, scratch, overflow_dst);
4416 Register scratch) {
4418 DCHECK(!dst.is(scratch));
4419 DCHECK(!overflow_dst.is(scratch));
4422 DCHECK(!scratch.is(left));
4423 DCHECK(!scratch.is(right));
4434 mov(scratch, left); // Preserve left.
4436 xor_(overflow_dst, dst, scratch); // scratch is original left.
4437 xor_(scratch, scratch, right); // scratch is original left.
4438 and_(overflow_dst, scratch, overflow_dst);
4440 mov(scratch, right); // Preserve right.
4443 xor_(scratch, left, scratch); // Original right.
4444 and_(overflow_dst, scratch, overflow_dst);
4448 xor_(scratch, left, right);
4449 and_(overflow_dst, scratch, overflow_dst);
4694 Register scratch,
4697 ld(scratch,
4699 ld(scratch, FieldMemOperand(scratch, GlobalObject::kNativeContextOffset));
4702 ld(scratch,
4703 MemOperand(scratch,
4707 ld(at, FieldMemOperand(scratch, offset));
4713 ld(map_in_out, FieldMemOperand(scratch, offset));
4731 Register scratch) {
4736 CheckMap(map, scratch, Heap::kMetaMapRootIndex, &fail, DO_SMI_CHECK);
4971 Register scratch,
4973 Dsubu(scratch, reg, Operand(1));
4975 scratch, Operand(zero_reg));
4976 and_(at, scratch, reg); // In the delay slot.
5080 Register scratch,
5083 andi(scratch, value, kSmiTagMask);
5084 Branch(bd, smi_label, eq, scratch, Operand(zero_reg));
5089 Register scratch,
5092 andi(scratch, value, kSmiTagMask);
5093 Branch(bd, not_smi_label, ne, scratch, Operand(zero_reg));
5175 Register scratch) {
5179 LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
5180 Branch(&done_checking, eq, object, Operand(scratch));
5183 LoadRoot(scratch, Heap::kAllocationSiteMapRootIndex);
5184 Assert(eq, kExpectedUndefinedOrCell, object, Operand(scratch));
5202 Register scratch,
5204 ld(scratch, FieldMemOperand(object, HeapObject::kMapOffset));
5206 Branch(on_not_heap_number, ne, scratch, Operand(heap_number_map));
5267 Register scratch = scratch1;
5268 // dsra(scratch, object, 1); // Shift away the tag.
5269 dsra32(scratch, scratch, 0);
5270 And(scratch, mask, Operand(scratch));
5274 dsll(scratch, scratch, kPointerSizeLog2 + 1);
5275 Daddu(scratch, number_string_cache, scratch);
5278 ld(probe, FieldMemOperand(scratch, FixedArray::kHeaderSize));
5283 ld(result, FieldMemOperand(scratch, FixedArray::kHeaderSize + kPointerSize));
5337 Register scratch,
5343 And(scratch, type, Operand(kFlatOneByteStringMask));
5344 Branch(failure, ne, scratch, Operand(kFlatOneByteStringTag));
5368 Register scratch,
5378 li(scratch, Operand(encoding_mask));
5379 Check(eq, kUnexpectedStringType, at, Operand(scratch));
5393 Register scratch) {
5408 mov(scratch, sp);
5412 sd(scratch, MemOperand(sp, stack_passed_arguments * kPointerSize));
5420 Register scratch) {
5421 PrepareCallCFunction(num_reg_arguments, 0, scratch);
5505 Register scratch,
5507 lwu(scratch, MemOperand(li_location));
5508 // At this point scratch is a lui(at, ...) instruction.
5510 And(scratch, scratch, kOpcodeMask);
5512 scratch, Operand(LUI));
5513 lwu(scratch, MemOperand(li_location));
5516 Ins(scratch, t9, 0, kImm16Bits);
5517 sw(scratch, MemOperand(li_location));
5519 lwu(scratch, MemOperand(li_location, kInstrSize));
5520 // scratch is now ori(at, ...).
5522 And(scratch, scratch, kOpcodeMask);
5524 scratch, Operand(ORI));
5525 lwu(scratch, MemOperand(li_location, kInstrSize));
5528 Ins(scratch, t9, 0, kImm16Bits);
5529 sw(scratch, MemOperand(li_location, kInstrSize));
5531 lwu(scratch, MemOperand(li_location, kInstrSize * 3));
5532 // scratch is now ori(at, ...).
5534 And(scratch, scratch, kOpcodeMask);
5536 scratch, Operand(ORI));
5537 lwu(scratch, MemOperand(li_location, kInstrSize * 3));
5540 Ins(scratch, new_value, 0, kImm16Bits);
5541 sw(scratch, MemOperand(li_location, kInstrSize * 3));
5549 Register scratch) {
5562 lwu(scratch, MemOperand(li_location, kInstrSize));
5564 And(scratch, scratch, kOpcodeMask);
5566 scratch, Operand(ORI));
5567 lwu(scratch, MemOperand(li_location, kInstrSize));
5569 // "scratch" now holds an ori instruction. Extract the immediate.
5570 andi(scratch, scratch, kImm16Mask);
5571 dsll32(scratch, scratch, 0);
5573 or_(value, value, scratch);
5575 lwu(scratch, MemOperand(li_location, kInstrSize * 3));
5577 And(scratch, scratch, kOpcodeMask);
5579 scratch, Operand(ORI));
5580 lwu(scratch, MemOperand(li_location, kInstrSize * 3));
5582 // "scratch" now holds an ori instruction. Extract the immediate.
5583 andi(scratch, scratch, kImm16Mask);
5584 dsll(scratch, scratch, kImm16Bits);
5586 or_(value, value, scratch);
5594 Register scratch,
5598 And(scratch, object, Operand(~Page::kPageAlignmentMask));
5599 ld(scratch, MemOperand(scratch, MemoryChunk::kFlagsOffset));
5600 And(scratch, scratch, Operand(mask));
5601 Branch(condition_met, cc, scratch, Operand(zero_reg));
5606 Register scratch,
5609 li(scratch, Operand(map));
5610 ld(scratch, FieldMemOperand(scratch, Map::kBitField3Offset));
5611 And(scratch, scratch, Operand(Map::Deprecated::kMask));
5612 Branch(if_deprecated, ne, scratch, Operand(zero_reg));
5655 Register scratch,
5657 DCHECK(!AreAliased(value, scratch, t8, no_reg));
5659 ld(scratch, FieldMemOperand(value, HeapObject::kMapOffset));
5661 Branch(&is_data_object, eq, t8, Operand(scratch));
5666 lbu(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
5667 And(t8, scratch, Operand(kIsIndirectStringMask | kIsNotStringMask));
5966 // Scratch contained elements pointer.
