Lines Matching refs:Register
17 const Register kReturnRegister0 = {Register::kCode_r3};
18 const Register kReturnRegister1 = {Register::kCode_r4};
19 const Register kReturnRegister2 = {Register::kCode_r5};
20 const Register kJSFunctionRegister = {Register::kCode_r4};
21 const Register kContextRegister = {Register::kCode_r30};
22 const Register kAllocateSizeRegister = {Register::kCode_r4};
23 const Register kInterpreterAccumulatorRegister = {Register::kCode_r3};
24 const Register kInterpreterBytecodeOffsetRegister = {Register::kCode_r15};
25 const Register kInterpreterBytecodeArrayRegister = {Register::kCode_r16};
26 const Register kInterpreterDispatchTableRegister = {Register::kCode_r17};
27 const Register kJavaScriptCallArgCountRegister = {Register::kCode_r3};
28 const Register kJavaScriptCallNewTargetRegister = {Register::kCode_r6};
29 const Register kRuntimeCallFunctionRegister = {Register::kCode_r4};
30 const Register kRuntimeCallArgCountRegister = {Register::kCode_r3};
36 inline MemOperand FieldMemOperand(Register object, int offset) {
59 Register GetRegisterThatIsNotOneOf(Register reg1, Register reg2 = no_reg,
60 Register reg3 = no_reg,
61 Register reg4 = no_reg,
62 Register reg5 = no_reg,
63 Register reg6 = no_reg);
67 bool AreAliased(Register reg1, Register reg2, Register reg3 = no_reg,
68 Register reg4 = no_reg, Register reg5 = no_reg,
69 Register reg6 = no_reg, Register reg7 = no_reg,
70 Register reg8 = no_reg, Register reg9 = no_reg,
71 Register reg10 = no_reg);
118 static int CallSize(Register target);
125 void Jump(Register target);
126 void JumpToJSEntry(Register target);
130 void Call(Register target);
131 void CallJSEntry(Register target);
149 Register reg, typename Descriptor::ParameterIndices parameter_index,
158 void Drop(Register count, Register scratch = r0);
167 // Register move. May do nothing if the registers are identical.
168 void Move(Register dst, Smi* smi) { LoadSmiLiteral(dst, smi); }
169 void Move(Register dst, Handle<Object> value);
170 void Move(Register dst, Register src, Condition cond = al);
173 void MultiPush(RegList regs, Register location = sp);
174 void MultiPop(RegList regs, Register location = sp);
176 void MultiPushDoubles(RegList dregs, Register location = sp);
177 void MultiPopDoubles(RegList dregs, Register location = sp);
180 void LoadRoot(Register destination, Heap::RootListIndex index,
183 void StoreRoot(Register source, Heap::RootListIndex index,
189 void IncrementalMarkingRecordWriteHelper(Register object, Register value,
190 Register address);
197 void RememberedSetHelper(Register object, // Used for debug code.
198 Register addr, Register scratch,
202 void CheckPageFlag(Register object, Register scratch, int mask, Condition cc,
207 void JumpIfNotInNewSpace(Register object, Register scratch, Label* branch) {
213 void JumpIfInNewSpace(Register object, Register scratch, Label* branch) {
218 void HasColor(Register object, Register scratch0, Register scratch1,
221 void JumpIfBlack(Register object, Register scratch0, Register scratch1,
226 void JumpIfWhite(Register value, Register scratch1, Register scratch2,
227 Register scratch3, Label* value_is_white);
235 Register object, int offset, Register value, Register scratch,
245 Register context, int offset, Register value, Register scratch,
258 void RecordWriteCodeEntryField(Register js_function, Register code_entry,
259 Register scratch);
261 void RecordWriteForMap(Register object, Register map, Register dst,
268 Register object, Register address, Register value,
275 void Push(Register src) { push(src); }
282 void Push(Register src1, Register src2) {
288 void Push(Register src1, Register src2, Register src3) {
295 void Push(Register src1, Register src2, Register src3, Register src4) {
303 void Push(Register src1, Register src2, Register src3, Register src4,
304 Register src5) {
312 void Pop(Register dst) { pop(dst); }
315 void Pop(Register src1, Register src2) {
322 void Pop(Register src1, Register src2, Register src3) {
330 void Pop(Register src1, Register src2, Register src3, Register src4) {
339 void Pop(Register src1, Register src2, Register src3, Register src4,
340 Register src5) {
350 void PushCommonFrame(Register marker_reg = no_reg);
354 void PushStandardFrame(Register function_reg);
356 void PopCommonFrame(Register marker_reg = no_reg);
368 void StoreToSafepointRegisterSlot(Register src, Register dst);
371 void LoadFromSafepointRegisterSlot(Register dst, Register src);
376 void FlushICache(Register address, size_t size, Register scratch);
386 void ConvertIntToDouble(Register src, DoubleRegister dst);
390 void ConvertUnsignedIntToDouble(Register src, DoubleRegister dst);
394 void ConvertIntToFloat(Register src, DoubleRegister dst);
398 void ConvertUnsignedIntToFloat(Register src, DoubleRegister dst);
401 void ConvertInt64ToFloat(Register src, DoubleRegister double_dst);
402 void ConvertInt64ToDouble(Register src, DoubleRegister double_dst);
403 void ConvertUnsignedInt64ToFloat(Register src, DoubleRegister double_dst);
404 void ConvertUnsignedInt64ToDouble(Register src, DoubleRegister double_dst);
411 const Register dst_hi,
413 const Register dst, const DoubleRegister double_dst,
420 const DoubleRegister double_input, const Register dst,
426 void ShiftLeftPair(Register dst_low, Register dst_high, Register src_low,
427 Register src_high, Register scratch, Register shift);
428 void ShiftLeftPair(Register dst_low, Register dst_high, Register src_low,
429 Register src_high, uint32_t shift);
430 void ShiftRightPair(Register dst_low, Register dst_high, Register src_low,
431 Register src_high, Register scratch, Register shift);
432 void ShiftRightPair(Register dst_low, Register dst_high, Register src_low,
433 Register src_high, uint32_t shift);
434 void ShiftRightAlgPair(Register dst_low, Register dst_high, Register src_low,
435 Register src_high, Register scratch, Register shift);
436 void ShiftRightAlgPair(Register dst_low, Register dst_high, Register src_low,
437 Register src_high, uint32_t shift);
441 void StubPrologue(StackFrame::Type type, Register base = no_reg,
443 void Prologue(bool code_pre_aging, Register base, int prologue_offset = 0);
454 void LeaveExitFrame(bool save_doubles, Register argument_count,
461 void LoadContext(Register dst, int context_chain_length);
464 void LoadGlobalObject(Register dst) {
469 void LoadGlobalProxy(Register dst) {
473 void LoadNativeContextSlot(int index, Register dst);
477 void LoadGlobalFunctionInitialMap(Register function, Register map,
478 Register scratch);
491 void LoadIntLiteral(Register dst, int value);
494 void LoadSmiLiteral(Register dst, Smi* smi);
497 void LoadDoubleLiteral(DoubleRegister result, double value, Register scratch);
499 void LoadWord(Register dst, const MemOperand& mem, Register scratch);
500 void LoadWordArith(Register dst, const MemOperand& mem,
501 Register scratch = no_reg);
502 void StoreWord(Register src, const MemOperand& mem, Register scratch);
504 void LoadHalfWord(Register dst, const MemOperand& mem, Register scratch);
505 void LoadHalfWordArith(Register dst, const MemOperand& mem,
506 Register scratch = no_reg);
507 void StoreHalfWord(Register src, const MemOperand& mem, Register scratch);
509 void LoadByte(Register dst, const MemOperand& mem, Register scratch);
510 void StoreByte(Register src, const MemOperand& mem, Register scratch);
512 void LoadRepresentation(Register dst, const MemOperand& mem, Representation r,
513 Register scratch = no_reg);
514 void StoreRepresentation(Register src, const MemOperand& mem,
515 Representation r, Register scratch = no_reg);
518 Register scratch = no_reg);
520 Register scratch = no_reg);
523 Register scratch = no_reg);
525 Register scratch = no_reg);
528 Register scratch = no_reg);
530 Register scratch = no_reg);
533 Register scratch = no_reg);
535 Register scratch = no_reg);
538 void MovIntToDouble(DoubleRegister dst, Register src, Register scratch);
539 void MovUnsignedIntToDouble(DoubleRegister dst, Register src,
540 Register scratch);
543 Register src_hi,
545 Register src);
547 void MovInt64ComponentsToDouble(DoubleRegister dst, Register src_hi,
548 Register src_lo, Register scratch);
550 void InsertDoubleLow(DoubleRegister dst, Register src, Register scratch);
551 void InsertDoubleHigh(DoubleRegister dst, Register src, Register scratch);
552 void MovDoubleLowToInt(Register dst, DoubleRegister src);
553 void MovDoubleHighToInt(Register dst, DoubleRegister src);
556 Register dst_hi,
558 Register dst, DoubleRegister src);
559 void MovIntToFloat(DoubleRegister dst, Register src);
560 void MovFloatToInt(Register dst, DoubleRegister src);
562 void Add(Register dst, Register src, intptr_t value, Register scratch);
563 void Cmpi(Register src1, const Operand& src2, Register scratch,
565 void Cmpli(Register src1, const Operand& src2, Register scratch,
567 void Cmpwi(Register src1, const Operand& src2, Register scratch,
569 void Cmplwi(Register src1, const Operand& src2, Register scratch,
571 void And(Register ra, Register rs, const Operand& rb, RCBit rc = LeaveRC);
572 void Or(Register ra, Register rs, const Operand& rb, RCBit rc = LeaveRC);
573 void Xor(Register ra, Register rs, const Operand& rb, RCBit rc = LeaveRC);
575 void AddSmiLiteral(Register dst, Register src, Smi* smi, Register scratch);
576 void SubSmiLiteral(Register dst, Register src, Smi* smi, Register scratch);
577 void CmpSmiLiteral(Register src1, Smi* smi, Register scratch,
579 void CmplSmiLiteral(Register src1, Smi* smi, Register scratch,
581 void AndSmiLiteral(Register dst, Register src, Smi* smi, Register scratch,
591 void LoadP(Register dst, const MemOperand& mem, Register scratch = no_reg);
592 void LoadPU(Register dst, const MemOperand& mem, Register scratch = no_reg);
593 void StoreP(Register src, const MemOperand& mem, Register scratch = no_reg);
594 void StorePU(Register src, const MemOperand& mem, Register scratch = no_reg);
605 Register caller_args_count_reg, Register scratch0,
606 Register scratch1);
609 void InvokeFunctionCode(Register function, Register new_target,
615 void CheckDebugHook(Register fun, Register new_target,
621 void InvokeFunction(Register function, Register new_target,
625 void InvokeFunction(Register function, const ParameterCount& expected,
634 void IsObjectJSStringType(Register object, Register scratch, Label* fail);
636 void IsObjectNameType(Register object, Register scratch, Label* fail);
654 void GetNumberHash(Register t0, Register scratch);
699 void Allocate(int object_size, Register result, Register scratch1,
700 Register scratch2, Label* gc_required, AllocationFlags flags);
702 void Allocate(Register object_size, Register result, Register result_end,
703 Register scratch, Label* gc_required, AllocationFlags flags);
708 void FastAllocate(int object_size, Register result, Register scratch1,
709 Register scratch2, AllocationFlags flags);
711 void FastAllocate(Register object_size, Register result, Register result_end,
712 Register scratch, AllocationFlags flags);
717 void AllocateHeapNumber(Register result, Register scratch1, Register scratch2,
718 Register heap_number_map, Label* gc_required,
720 void AllocateHeapNumberWithValue(Register result, DoubleRegister value,
721 Register scratch1, Register scratch2,
722 Register heap_number_map,
727 void AllocateJSValue(Register result, Register constructor, Register value,
728 Register scratch1, Register scratch2,
735 void InitializeNFieldsWithFiller(Register current_address, Register count,
736 Register filler);
741 void InitializeFieldsWithFiller(Register current_address,
742 Register end_address, Register filler);
749 void GetMapConstructor(Register result, Register map, Register temp,
750 Register temp2);
760 void CompareObjectType(Register heap_object, Register map, Register type_reg,
766 void CompareInstanceType(Register map, Register type_reg, InstanceType type);
772 void CompareMap(Register obj, Register scratch, Handle<Map> map,
777 void CompareMap(Register obj_map, Handle<Map> map, Label* early_success);
783 void CheckMap(Register obj, Register scratch, Handle<Map> map, Label* fail,
787 void CheckMap(Register obj, Register scratch, Heap::RootListIndex index,
794 void DispatchWeakMap(Register obj, Register scratch1, Register scratch2,
799 void CmpWeakValue(Register value, Handle<WeakCell> cell, Register scratch,
802 void GetWeakValue(Register value, Handle<WeakCell> cell);
806 void LoadWeakValue(Register value, Handle<WeakCell> cell, Label* miss);
810 void CompareRoot(Register obj, Heap::RootListIndex index);
817 void JumpIfRoot(Register with, Heap::RootListIndex index, Label* if_equal) {
823 void JumpIfNotRoot(Register with, Heap::RootListIndex index,
832 Condition IsObjectStringType(Register obj, Register type) {
841 void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
842 void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
845 void SmiToDouble(DoubleRegister value, Register smi);
849 void TestDoubleIsInt32(DoubleRegister double_input, Register scratch1,
850 Register scratch2, DoubleRegister double_scratch);
854 void TestDoubleIsMinusZero(DoubleRegister input, Register scratch1,
855 Register scratch2);
859 void TestDoubleSign(DoubleRegister input, Register scratch);
860 void TestHeapNumberSign(Register input, Register scratch);
864 void TryDoubleToInt32Exact(Register result, DoubleRegister double_input,
865 Register scratch, DoubleRegister double_scratch);
871 void TryInt32Floor(Register result, DoubleRegister double_input,
872 Register input_high, Register scratch,
881 void TryInlineTruncateDoubleToI(Register result, DoubleRegister input,
887 void TruncateDoubleToI(Register result, DoubleRegister double_input);
892 void TruncateHeapNumberToI(Register result, Register object);
898 void TruncateNumberToI(Register object, Register result,
899 Register heap_number_map, Register scratch1,
909 void AddAndCheckForOverflow(Register dst, Register left, Register right,
910 Register overflow_dst, Register scratch = r0);
911 void AddAndCheckForOverflow(Register dst, Register left, intptr_t right,
912 Register overflow_dst, Register scratch = r0);
917 void SubAndCheckForOverflow(Register dst, Register left, Register right,
918 Register overflow_dst, Register scratch = r0);
979 Register scratch);
980 void PrepareCallCFunction(int num_reg_arguments, Register scratch);
996 void CallCFunction(Register function, int num_arguments);
999 void CallCFunction(Register function, int num_reg_arguments,
1017 void TruncatingDiv(Register result, Register dividend, int32_t divisor);
1022 void SetCounter(StatsCounter* counter, int value, Register scratch1,
1023 Register scratch2);
1024 void IncrementCounter(StatsCounter* counter, int value, Register scratch1,
1025 Register scratch2);
1026 void DecrementCounter(StatsCounter* counter, int value, Register scratch1,
1027 Register scratch2);
1036 void AssertFastElements(Register elements);
1058 void JumpIfNotPowerOfTwoOrZero(Register reg, Register scratch,
1066 void JumpIfNotPowerOfTwoOrZeroAndNeg(Register reg, Register scratch,
1078 inline void ExtractBitRange(Register dst, Register src, int rangeStart,
1097 inline void ExtractBit(Register dst, Register src, uint32_t bitNumber,
1104 inline void ExtractBitMask(Register dst, Register src, uintptr_t mask,
1129 inline void TestBit(Register value, int bitNumber, Register scratch = r0) {
1135 inline void TestBitRange(Register value, int rangeStart, int rangeEnd,
1136 Register scratch = r0) {
1141 inline void TestBitMask(Register value, uintptr_t mask,
1142 Register scratch = r0) {
1151 void SmiTag(Register reg, RCBit rc = LeaveRC) { SmiTag(reg, reg, rc); }
1152 void SmiTag(Register dst, Register src, RCBit rc = LeaveRC) {
1158 void SmiTagCheckOverflow(Register reg, Register overflow);
1159 void SmiTagCheckOverflow(Register dst, Register src, Register overflow);
1161 inline void JumpIfNotSmiCandidate(Register value, Register scratch,
1170 inline void TestUnsignedSmiCandidate(Register value, Register scratch) {
1177 inline void JumpIfNotUnsignedSmiCandidate(Register value, Register scratch,
1183 void SmiUntag(Register reg, RCBit rc = LeaveRC) { SmiUntag(reg, reg, rc); }
1185 void SmiUntag(Register dst, Register src, RCBit rc = LeaveRC) {
1189 void SmiToPtrArrayOffset(Register dst, Register src) {
1199 void SmiToByteArrayOffset(Register dst, Register src) { SmiUntag(dst, src); }
1201 void SmiToShortArrayOffset(Register dst, Register src) {
1213 void SmiToIntArrayOffset(Register dst, Register src) {
1225 void SmiToDoubleArrayOffset(Register dst, Register src) {
1235 void SmiToArrayOffset(Register dst, Register src, int elementSizeLog2) {
1245 void IndexToArrayOffset(Register dst, Register src, int elementSizeLog2,
1256 void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case);
1258 inline void TestIfSmi(Register value, Register scratch) {
1262 inline void TestIfPositiveSmi(Register value, Register scratch) {
1272 inline void JumpIfSmi(Register value, Label* smi_label) {
1277 inline void JumpIfNotSmi(Register value, Label* not_smi_label) {
1282 void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi);
1284 void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi);
1287 void AssertNotNumber(Register object);
1290 void AssertNotSmi(Register object);
1291 void AssertSmi(Register object);
1295 inline void TestIfInt32(Register value, Register scratch,
1302 inline void TestIfInt32(Register hi_word, Register lo_word, Register scratch,
1323 void AssertString(Register object);
1326 void AssertName(Register object);
1328 void AssertFunction(Register object);
1332 void AssertBoundFunction(Register object);
1336 void AssertGeneratorObject(Register object);
1339 void AssertReceiver(Register object);
1343 void AssertUndefinedOrAllocationSite(Register object, Register scratch);
1347 void AssertIsRoot(Register reg, Heap::RootListIndex index);
1352 void JumpIfNotHeapNumber(Register object, Register heap_number_map,
1353 Register scratch, Label* on_not_heap_number);
1360 void JumpIfNonSmisNotBothSequentialOneByteStrings(Register object1,
1361 Register object2,
1362 Register scratch1,
1363 Register scratch2,
1368 void JumpIfNotBothSequentialOneByteStrings(Register first, Register second,
1369 Register scratch1,
1370 Register scratch2,
1376 Register first_object_instance_type, Register second_object_instance_type,
1377 Register scratch1, Register scratch2, Label* failure);
1379 void JumpIfNotUniqueNameInstanceType(Register reg, Label* not_unique_name);
1381 void EmitSeqStringSetCharCheck(Register string, Register index,
1382 Register value, uint32_t encoding_mask);
1389 void DecodeConstantPoolOffset(Register result, Register location);
1391 void ClampUint8(Register output_reg, Register input_reg);
1397 void ClampDoubleToUint8(Register result_reg, DoubleRegister input_reg,
1401 void LoadInstanceDescriptors(Register map, Register descriptors);
1402 void EnumLength(Register dst, Register map);
1403 void NumberOfOwnDescriptors(Register dst, Register map);
1404 void LoadAccessor(Register dst, Register holder, int accessor_index,
1408 void DecodeField(Register dst, Register src, RCBit rc = LeaveRC) {
1414 void DecodeField(Register reg, RCBit rc = LeaveRC) {
1419 void DecodeFieldToSmi(Register dst, Register src) {
1437 void DecodeFieldToSmi(Register reg) {
1442 void EmitLoadFeedbackVector(Register vector);
1450 void EnterBuiltinFrame(Register context, Register target, Register argc);
1451 void LeaveBuiltinFrame(Register context, Register target, Register argc);
1463 void TestJSArrayForAllocationMemento(Register receiver_reg,
1464 Register scratch_reg,
1465 Register scratch2_reg,
1470 Register code_target_address);
1472 void LoadConstantPoolPointerRegister(Register base, int code_entry_delta = 0);
1484 void CallCFunctionHelper(Register function, int num_reg_arguments,
1497 void InNewSpace(Register object, Register scratch,
1504 inline void GetMarkBits(Register addr_reg, Register bitmap_reg,
1505 Register mask_reg);
1512 MemOperand SafepointRegisterSlot(Register reg);
1513 MemOperand SafepointRegistersAndDoublesSlot(Register reg);
1560 inline MemOperand ContextMemOperand(Register context, int index = 0) {