Lines Matching refs:scratch
373 Register LCodeGen::EmitLoadRegister(LOperand* op, Register scratch) {
383 __ li(scratch, Operand(static_cast<int32_t>(literal->Number())));
386 __ li(scratch, Operand(Smi::FromInt(constant->Integer32Value())));
391 __ li(scratch, literal);
393 return scratch;
395 __ ld(scratch, ToMemOperand(op));
396 return scratch;
399 return scratch;
784 Register scratch = scratch0();
787 __ Push(a1, scratch);
788 __ li(scratch, Operand(count));
789 __ lw(a1, MemOperand(scratch));
793 __ sw(a1, MemOperand(scratch));
794 __ Pop(a1, scratch);
798 __ sw(a1, MemOperand(scratch));
799 __ Pop(a1, scratch);
1283 Register scratch = result.is(dividend) ? scratch0() : dividend;
1284 DCHECK(!result.is(dividend) || !scratch.is(dividend));
1303 __ Move(scratch, dividend);
1310 __ Xor(scratch, scratch, result);
1326 __ Branch(&no_overflow, lt, scratch, Operand(zero_reg));
1430 Register scratch = scratch0();
1452 __ SubuAndCheckForOverflow(result, zero_reg, left, scratch);
1453 DeoptimizeIf(gt, instr, scratch, Operand(kMaxInt));
1484 __ dsll(scratch, left, shift);
1485 __ Daddu(result, scratch, left);
1490 __ dsll(scratch, left, shift);
1491 __ Dsubu(result, scratch, left);
1512 __ dsra32(scratch, result, 0);
1517 DeoptimizeIf(ne, instr, scratch, Operand(at));
1672 Register scratch = scratch1();
1674 Register right_reg = EmitLoadRegister(right, scratch);
1678 overflow); // Reg at also used as scratch.
1686 overflow); // Reg at also used as scratch.
1737 Register scratch = ToRegister(instr->temp());
1742 DCHECK(!scratch.is(scratch0()));
1743 DCHECK(!scratch.is(object));
1747 __ GetObjectType(object, scratch, scratch);
1748 DeoptimizeIf(ne, instr, scratch, Operand(JS_DATE_TYPE));
1755 __ li(scratch, Operand(stamp));
1756 __ ld(scratch, MemOperand(scratch));
1758 __ Branch(&runtime, ne, scratch, Operand(scratch0()));
1764 __ PrepareCallCFunction(2, scratch);
1783 Register scratch = scratch0();
1784 DCHECK(!scratch.is(string));
1785 DCHECK(!scratch.is(ToRegister(index)));
1787 __ Daddu(scratch, string, ToRegister(index));
1790 __ dsll(scratch, ToRegister(index), 1);
1791 __ Daddu(scratch, string, scratch);
1793 return FieldMemOperand(scratch, SeqString::kHeaderSize);
1803 Register scratch = scratch0();
1804 __ ld(scratch, FieldMemOperand(string, HeapObject::kMapOffset));
1805 __ lbu(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
1807 __ And(scratch, scratch,
1811 __ Dsubu(at, scratch, Operand(encoding == String::ONE_BYTE_ENCODING
1831 Register scratch = scratch0();
1838 __ EmitSeqStringSetCharCheck(string, index, value, scratch, encoding_mask);
1866 Register scratch = scratch1();
1869 Register right_reg = EmitLoadRegister(right, scratch);
1873 overflow); // Reg at also used as scratch.
1881 overflow); // Reg at also used as scratch.
1903 Register scratch = scratch1();
1904 __ Slt(scratch, left_reg, Operand(right_reg));
1906 __ Movz(result_reg, left_reg, scratch);
1907 __ Movn(result_reg, right_reg, scratch);
1910 __ Movn(result_reg, left_reg, scratch);
1911 __ Movz(result_reg, right_reg, scratch);
2183 const Register scratch = scratch1();
2184 __ lbu(scratch, FieldMemOperand(map, Map::kInstanceTypeOffset));
2185 __ Branch(instr->TrueLabel(chunk_), eq, scratch, Operand(SYMBOL_TYPE));
2337 Register scratch = scratch0();
2338 __ FmoveHigh(scratch, input_reg);
2339 EmitBranch(instr, eq, scratch, Operand(kHoleNanUpper32));
2346 Register scratch = ToRegister(instr->temp());
2351 __ FmoveHigh(scratch, value);
2353 __ dsll32(scratch, scratch, 0);
2354 __ dsrl32(scratch, scratch, 0);
2359 scratch,
2363 __ lwu(scratch, FieldMemOperand(value, HeapNumber::kExponentOffset));
2364 EmitFalseBranch(instr, ne, scratch, Operand(0x80000000));
2365 __ lwu(scratch, FieldMemOperand(value, HeapNumber::kMantissaOffset));
2368 EmitBranch(instr, eq, scratch, Operand(at));
2515 Register scratch = scratch0();
2522 __ GetObjectType(input, scratch, scratch);
2525 scratch,
2544 Register scratch = scratch0();
2546 __ lwu(scratch,
2548 __ And(at, scratch, Operand(String::kContainsCachedArrayIndexMask));
2933 Register scratch = scratch0();
2939 __ ld(scratch, target);
2943 DeoptimizeIf(eq, instr, scratch, Operand(at));
2945 __ Branch(&skip_assignment, ne, scratch, Operand(at));
2996 Register scratch = scratch0();
2997 __ Load(scratch, FieldMemOperand(object, offset), representation);
2998 __ AssertSmi(scratch);
3027 Register scratch = scratch0();
3041 __ GetObjectType(result, scratch, scratch);
3042 __ Branch(&done, ne, scratch, Operand(MAP_TYPE));
3210 Register scratch = scratch0();
3222 __ Daddu(scratch, elements, Operand(base_offset));
3236 __ Daddu(scratch, scratch, at);
3239 __ ldc1(result, MemOperand(scratch));
3242 __ lw(scratch, MemOperand(scratch, sizeof(kHoleNanLower32)));
3243 DeoptimizeIf(eq, instr, scratch, Operand(kHoleNanUpper32));
3252 Register scratch = scratch0();
3253 Register store_base = scratch;
3267 __ SmiScale(scratch, key, kPointerSizeLog2);
3268 __ daddu(scratch, elements, scratch);
3270 __ dsll(scratch, key, kPointerSizeLog2);
3271 __ daddu(scratch, elements, scratch);
3296 __ SmiTst(result, scratch);
3297 DeoptimizeIf(ne, instr, scratch, Operand(zero_reg));
3299 __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
3300 DeoptimizeIf(eq, instr, result, Operand(scratch));
3375 Register scratch = scratch0();
3384 __ ld(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
3385 __ ld(result, MemOperand(scratch, StandardFrameConstants::kContextOffset));
3391 __ Movz(result, scratch, temp); // Move only if temp is equal to zero (eq).
3421 Register scratch = scratch0();
3430 __ ld(scratch,
3439 FieldMemOperand(scratch, SharedFunctionInfo::kStrictModeByteOffset));
3443 FieldMemOperand(scratch, SharedFunctionInfo::kNativeByteOffset));
3449 __ LoadRoot(scratch, Heap::kNullValueRootIndex);
3450 __ Branch(&global_object, eq, receiver, Operand(scratch));
3451 __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
3452 __ Branch(&global_object, eq, receiver, Operand(scratch));
3455 __ SmiTst(receiver, scratch);
3456 DeoptimizeIf(eq, instr, scratch, Operand(zero_reg));
3458 __ GetObjectType(receiver, scratch, scratch);
3459 DeoptimizeIf(lt, instr, scratch, Operand(FIRST_SPEC_OBJECT_TYPE));
3486 Register scratch = scratch0();
3508 __ dsll(scratch, length, kPointerSizeLog2);
3510 __ Daddu(scratch, elements, scratch);
3511 __ ld(scratch, MemOperand(scratch));
3512 __ push(scratch);
3515 __ dsll(scratch, length, kPointerSizeLog2);
3619 Register scratch = scratch0();
3622 __ ld(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
3624 DeoptimizeIf(ne, instr, scratch, Operand(at));
3628 scratch = no_reg;
3642 // many scratch registers.
3763 Register scratch = scratch0();
3768 __ Ext(scratch,
3775 __ Branch(&skip1, gt, scratch, Operand(HeapNumber::kExponentBias - 2));
3786 DeoptimizeIf(ge, instr, scratch, Operand(HeapNumber::kExponentBias + 32));
3789 __ And(scratch, result, Operand(HeapNumber::kSignMask));
3800 __ Xor(result, result, Operand(scratch));
3814 Register except_flag = scratch;
3828 __ mfhc1(scratch, input); // Get exponent/sign bits.
3829 __ And(scratch, scratch, Operand(HeapNumber::kSignMask));
3830 DeoptimizeIf(ne, instr, scratch
3971 Register scratch = a3;
3982 scratch, extra, extra2, extra3);
4345 Register scratch = scratch0();
4359 __ Daddu(scratch, elements,
4365 __ Daddu(scratch, elements, Operand(base_offset));
4372 __ Daddu(scratch, scratch, at);
4385 __ sdc1(double_scratch, MemOperand(scratch, 0));
4390 __ sdc1(value, MemOperand(scratch, 0));
4400 Register scratch = scratch0();
4401 Register store_base = scratch;
4416 __ SmiScale(scratch, key, kPointerSizeLog2);
4417 __ daddu(store_base, elements, scratch);
4419 __ dsll(scratch, key, kPointerSizeLog2);
4420 __ daddu(store_base, elements, scratch);
4487 Register scratch = scratch0();
4495 __ ld(scratch, FieldMemOperand(object_reg, HeapObject::kMapOffset));
4496 __ Branch(¬_applicable, ne, scratch, Operand(from_map));
4505 scratch,
4572 Register scratch = scratch0();
4585 __ Daddu(scratch, zero_reg, Operand(Smi::FromInt(const_index)));
4586 __ push(scratch);
4619 Register scratch = scratch0();
4625 __ dsll(scratch, char_code, kPointerSizeLog2);
4626 __ Daddu(result, result, scratch);
4628 __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
4629 __ Branch(deferred->entry(), eq, result, Operand(scratch));
4658 Register scratch = scratch0();
4659 __ ld(scratch, ToMemOperand(input));
4660 __ mtc1(scratch, single_scratch);
4782 Register scratch = scratch0();
4789 __ LoadRoot(scratch, Heap::kHeapNumberMapRootIndex);
4791 __ AllocateHeapNumber(reg, temp1, temp2, scratch, deferred->entry(),
4845 Register scratch = scratch0();
4850 // If the input is a HeapObject, value of scratch won't be zero.
4851 __ And(scratch, input, Operand(kHeapObjectTag));
4853 DeoptimizeIf(ne, instr, scratch, Operand(zero_reg));
4867 Register scratch = scratch0();
4871 __ UntagAndJumpIfSmi(scratch, input_reg, &load_smi);
4873 __ ld(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
4876 __ Branch(&convert, ne, scratch, Operand(at));
4878 DeoptimizeIf(ne, instr, scratch, Operand(at));
4885 __ mfhc1(scratch, result_reg); // Get exponent/sign bits.
4886 DeoptimizeIf(eq, instr, scratch, Operand(HeapNumber::kSignMask));
4894 __ LoadRoot(scratch, Heap::kNanValueRootIndex);
4895 __ ldc1(result_reg, FieldMemOperand(scratch, HeapNumber::kValueOffset));
4899 __ SmiUntag(scratch, input_reg);
4904 // scratch: untagged value of input_reg
4905 __ mtc1(scratch, result_reg);
5127 Register scratch = scratch0();
5129 __ GetObjectType(input, scratch, scratch);
5138 DeoptimizeIf(ne, instr, scratch, Operand(first));
5140 DeoptimizeIf(lo, instr, scratch, Operand(first));
5143 DeoptimizeIf(hi, instr, scratch, Operand(last));
5153 __ And(at, scratch, mask);
5156 __ And(scratch, scratch, Operand(mask));
5157 DeoptimizeIf(ne, instr, scratch, Operand(tag));
5266 Register scratch = scratch0();
5273 __ UntagAndJumpIfSmi(scratch, input_reg, &is_smi);
5276 __ ld(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
5277 __ Branch(&heap_number, eq, scratch, Operand(factory()->heap_number_map()));
5293 __ ClampUint8(result_reg, scratch);
5335 Register scratch = ToRegister(instr->temp1());
5354 __ Allocate(size, result, scratch, scratch2, deferred->entry(), flags);
5360 __ Allocate(size, result, scratch, scratch2, deferred->entry(), flags);
5369 __ li(scratch, Operand(size - kHeapObjectTag));
5371 __ Dsubu(scratch, ToRegister(instr->size()), Operand(kHeapObjectTag));
5376 __ Dsubu(scratch, scratch, Operand(kPointerSize));
5377 __ Daddu(at, result, Operand(scratch));
5379 __ Branch(&loop, ge, scratch, Operand(zero_reg));
5552 Register scratch = scratch0();
5564 __ GetObjectType(input, input, scratch);
5566 ge, scratch, Operand(FIRST_NONSTRING_TYPE));
5577 __ GetObjectType(input, input, scratch);
5578 *cmp1 = scratch;
5607 __ GetObjectType(input, scratch, input);
5618 __ GetObjectType(input, map, scratch);
5620 lt, scratch, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
5622 gt, scratch, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
5902 Register scratch = scratch0();
5910 __ And(scratch, index, Operand(Smi::FromInt(1)));
5911 __ Branch(deferred->entry(), ne, scratch, Operand(zero_reg));
5915 __ SmiScale(scratch, index, kPointerSizeLog2); // In delay slot.
5916 __ Daddu(scratch, object, scratch);
5917 __ ld(result, FieldMemOperand(scratch, JSObject::kHeaderSize));
5924 __ Dsubu(scratch, result, scratch);
5925 __ ld(result, FieldMemOperand(scratch,
