Lines Matching refs:Register
19 const Register kScratchRegister = { 10 }; // r10.
20 const Register kSmiConstantRegister = { 12 }; // r12 (callee save).
21 const Register kRootRegister = { 13 }; // r13 (callee save).
55 bool AreAliased(Register reg1,
56 Register reg2,
57 Register reg3 = no_reg,
58 Register reg4 = no_reg,
59 Register reg5 = no_reg,
60 Register reg6 = no_reg,
61 Register reg7 = no_reg,
62 Register reg8 = no_reg);
69 SmiIndex(Register index_register, ScaleFactor scale)
72 Register reg;
110 Register scratch = kScratchRegister);
117 void Load(Register destination, ExternalReference source);
118 void Store(ExternalReference destination, Register source);
121 void LoadAddress(Register destination, ExternalReference source);
129 void LoadRoot(Register destination, Heap::RootListIndex index);
130 void StoreRoot(Register source, Heap::RootListIndex index);
134 void LoadRootIndexed(Register destination,
135 Register variable_offset,
137 void CompareRoot(Register with, Heap::RootListIndex index);
145 Register exclusion1 = no_reg,
146 Register exclusion2 = no_reg,
147 Register exclusion3 = no_reg);
149 Register exclusion1 = no_reg,
150 Register exclusion2 = no_reg,
151 Register exclusion3 = no_reg);
165 void RememberedSetHelper(Register object, // Used for debug code.
166 Register addr,
167 Register scratch,
171 void CheckPageFlag(Register object,
172 Register scratch,
179 Register scratch,
184 void JumpIfNotInNewSpace(Register object,
185 Register scratch,
193 void JumpIfInNewSpace(Register object,
194 Register scratch,
201 void JumpIfBlack(Register object,
202 Register scratch0,
203 Register scratch1,
209 void JumpIfDataObject(Register value,
210 Register scratch,
219 void EnsureNotWhite(Register object,
220 Register scratch1,
221 Register scratch2,
231 Register object,
233 Register value,
234 Register scratch,
244 Register context,
246 Register value,
247 Register scratch,
270 Register array,
271 Register value,
272 Register index,
280 Register object,
281 Register map,
282 Register dst,
291 Register object,
292 Register address,
293 Register value,
336 void StoreToSafepointRegisterSlot(Register dst, const Immediate& imm);
337 void StoreToSafepointRegisterSlot(Register dst, Register src);
338 void LoadFromSafepointRegisterSlot(Register dst, Register src);
351 void InvokeCode(Register code,
359 void InvokeFunction(Register function,
364 void InvokeFunction(Register function,
383 void GetBuiltinFunction(Register target, Builtins::JavaScript id);
386 void GetBuiltinEntry(Register target, Builtins::JavaScript id);
394 void SafeMove(Register dst, Smi* src);
407 void Integer32ToSmi(Register dst, Register src);
410 void Integer32ToSmiField(const Operand& dst, Register src);
414 void Integer64PlusConstantToSmi(Register dst, Register src, int constant);
418 void SmiToInteger32(Register dst, Register src);
419 void SmiToInteger32(Register dst, const Operand& src);
422 void SmiToInteger64(Register dst, Register src);
423 void SmiToInteger64(Register dst, const Operand& src);
427 void PositiveSmiTimesPowerOfTwoToInteger64(Register dst,
428 Register src,
433 void PositiveSmiDivPowerOfTwoToInteger32(Register dst,
434 Register src,
441 void SmiOrIfSmis(Register dst,
442 Register src1,
443 Register src2,
450 void SmiCompare(Register smi1, Register smi2);
451 void SmiCompare(Register dst, Smi* src);
452 void SmiCompare(Register dst, const Operand& src);
453 void SmiCompare(const Operand& dst, Register src);
456 void SmiCompareInteger32(const Operand& dst, Register src);
458 void SmiTest(Register src);
464 Condition CheckSmi(Register src);
468 Condition CheckNonNegativeSmi(Register src);
471 Condition CheckBothSmi(Register first, Register second);
474 Condition CheckBothNonNegativeSmi(Register first, Register second);
477 Condition CheckEitherSmi(Register first,
478 Register second,
479 Register scratch = kScratchRegister);
484 Condition CheckIsMinSmi(Register src);
488 Condition CheckInteger32ValidSmiValue(Register src);
492 Condition CheckUInteger32ValidSmiValue(Register src);
496 void CheckSmiToIndicator(Register dst, Register src);
497 void CheckSmiToIndicator(Register dst, const Operand& src);
503 void JumpIfValidSmiValue(Register src, Label* on_valid,
507 void JumpIfNotValidSmiValue(Register src, Label* on_invalid,
511 void JumpIfUIntValidSmiValue(Register src, Label* on_valid,
515 void JumpIfUIntNotValidSmiValue(Register src, Label* on_invalid,
519 void JumpIfSmi(Register src,
524 void JumpIfNotSmi(Register src,
529 void JumpUnlessNonNegativeSmi(Register src,
535 void JumpIfSmiEqualsConstant(Register src,
541 void JumpIfNotBothSmi(Register src1,
542 Register src2,
547 void JumpUnlessBothNonNegativeSmi(Register src1, Register src2,
558 void SmiAddConstant(Register dst, Register src, Smi* constant);
566 void SmiAddConstant(Register dst,
567 Register src,
576 void SmiSubConstant(Register dst, Register src, Smi* constant);
580 void SmiSubConstant(Register dst,
581 Register src,
589 void SmiNeg(Register dst,
590 Register src,
597 void SmiAdd(Register dst,
598 Register src1,
599 Register src2,
602 void SmiAdd(Register dst,
603 Register src1,
608 void SmiAdd(Register dst,
609 Register src1,
610 Register src2);
615 void SmiSub(Register dst,
616 Register src1,
617 Register src2,
620 void SmiSub(Register dst,
621 Register src1,
626 void SmiSub(Register dst,
627 Register src1,
628 Register src2);
630 void SmiSub(Register dst,
631 Register src1,
638 void SmiMul(Register dst,
639 Register src1,
640 Register src2,
646 void SmiDiv(Register dst,
647 Register src1,
648 Register src2,
654 void SmiMod(Register dst,
655 Register src1,
656 Register src2,
661 void SmiNot(Register dst, Register src);
662 void SmiAnd(Register dst, Register src1, Register src2);
663 void SmiOr(Register dst, Register src1, Register src2);
664 void SmiXor(Register dst, Register src1, Register src2);
665 void SmiAndConstant(Register dst, Register src1, Smi* constant);
666 void SmiOrConstant(Register dst, Register src1, Smi* constant);
667 void SmiXorConstant(Register dst, Register src1, Smi* constant);
669 void SmiShiftLeftConstant(Register dst,
670 Register src,
674 void SmiShiftLogicalRightConstant(Register dst,
675 Register src,
679 void SmiShiftArithmeticRightConstant(Register dst,
680 Register src,
685 void SmiShiftLeft(Register dst,
686 Register src1,
687 Register src2,
693 void SmiShiftLogicalRight(Register dst,
694 Register src1,
695 Register src2,
703 void SmiShiftArithmeticRight(Register dst,
704 Register src1,
705 Register src2);
711 void SelectNonSmi(Register dst,
712 Register src1,
713 Register src2,
725 SmiIndex SmiToIndex(Register dst, Register src, int shift);
728 SmiIndex SmiToNegativeIndex(Register dst, Register src, int shift);
732 void AddSmiField(Register dst, const Operand& src);
735 void Move(Register dst, Smi* source) {
740 Register constant = GetSmiConstant(source);
748 void PushRegisterAsTwoSmis(Register src, Register scratch = kScratchRegister);
751 void PopRegisterAsTwoSmis(Register dst, Register scratch = kScratchRegister);
764 void LookupNumberStringCache(Register object,
765 Register result,
766 Register scratch1,
767 Register scratch2,
771 void JumpIfNotString(Register object,
772 Register object_map,
778 Register first_object, Register second_object, Register scratch1,
779 Register scratch2, Label* on_not_both_flat_one_byte,
786 Register instance_type, Register scratch,
791 Register first_object_instance_type, Register second_object_instance_type,
792 Register scratch1, Register scratch2, Label* on_fail,
795 void EmitSeqStringSetCharCheck(Register string,
796 Register index,
797 Register value,
801 void JumpIfNotUniqueNameInstanceType(Register reg, Label* not_unique_name,
810 void Load(Register dst, const Operand& src, Representation r);
811 void Store(const Operand& dst, Register src, Representation r);
814 void Set(Register dst, int64_t x);
820 void Cvtlsi2sd(XMMRegister dst, Register src);
824 void Move(Register target, Register source);
827 void TestBitSharedFunctionInfoSpecialField(Register base,
830 void LoadSharedFunctionInfoSpecialField(Register dst,
831 Register base,
835 void Move(Register dst, Handle<Object> source);
837 void Cmp(Register dst, Handle<Object> source);
839 void Cmp(Register dst, Smi* src);
845 void MoveHeapObject(Register result, Handle<Object> object);
848 void LoadGlobalCell(Register dst, Handle<Cell> cell);
857 Register scratch = kScratchRegister);
860 void Push(Register src);
865 void Pop(Register dst);
868 void PushReturnAddressFrom(Register src) { pushq(src); }
869 void PopReturnAddressTo(Register dst) { popq(dst); }
870 void Move(Register dst, ExternalReference ext) {
876 void Move(Register dst, void* ptr, RelocInfo::Mode rmode) {
883 void Move(Register dst, Handle<Object> value, RelocInfo::Mode rmode) {
913 int CallSize(Register target) {
942 void CmpObjectType(Register heap_object, InstanceType type, Register map);
946 void CmpInstanceType(Register map, InstanceType type);
950 void CheckFastElements(Register map,
956 void CheckFastObjectElements(Register map,
962 void CheckFastSmiElements(Register map,
970 void StoreNumberToDoubleElements(Register maybe_number,
971 Register elements,
972 Register index,
978 void CompareMap(Register obj, Handle<Map> map);
984 void CheckMap(Register obj,
992 void DispatchMap(Register obj,
993 Register unused,
1003 Condition IsObjectStringType(Register heap_object,
1004 Register map,
1005 Register instance_type);
1012 Condition IsObjectNameType(Register heap_object,
1013 Register map,
1014 Register instance_type);
1021 void ClampUint8(Register reg);
1025 Register result_reg);
1027 void SlowTruncateToI(Register result_reg, Register input_reg,
1030 void TruncateHeapNumberToI(Register result_reg, Register input_reg);
1031 void TruncateDoubleToI(Register result_reg, XMMRegister input_reg);
1033 void DoubleToI(Register result_reg, XMMRegister input_reg,
1038 void LoadUint32(XMMRegister dst, Register src);
1040 void LoadInstanceDescriptors(Register map, Register descriptors);
1041 void EnumLength(Register dst, Register map);
1042 void NumberOfOwnDescriptors(Register dst, Register map);
1045 void DecodeField(Register reg) {
1055 void DecodeFieldToSmi(Register reg) {
1075 void AssertNumber(Register object);
1078 void AssertNotSmi(Register object);
1081 void AssertSmi(Register object);
1086 void AssertZeroExtended(Register reg);
1089 void AssertString(Register object);
1092 void AssertName(Register object);
1096 void AssertUndefinedOrAllocationSite(Register object);
1100 void AssertRootValue(Register src,
1115 void Throw(Register value);
1118 void ThrowUncatchable(Register value);
1127 void CheckAccessGlobalProxy(Register holder_reg,
1128 Register scratch,
1131 void GetNumberHash(Register r0, Register scratch);
1134 Register elements,
1135 Register key,
1136 Register r0,
1137 Register r1,
1138 Register r2,
1139 Register result);
1156 Register result,
1157 Register result_end,
1158 Register scratch,
1164 Register element_count,
1165 Register result,
1166 Register result_end,
1167 Register scratch,
1171 void Allocate(Register object_size,
1172 Register result,
1173 Register result_end,
1174 Register scratch,
1182 void UndoAllocationInNewSpace(Register object);
1187 void AllocateHeapNumber(Register result,
1188 Register scratch,
1194 void AllocateTwoByteString(Register result,
1195 Register length,
1196 Register scratch1,
1197 Register scratch2,
1198 Register scratch3,
1200 void AllocateOneByteString(Register result, Register length,
1201 Register scratch1, Register scratch2,
1202 Register scratch3, Label* gc_required);
1206 void AllocateTwoByteConsString(Register result,
1207 Register scratch1,
1208 Register scratch2,
1210 void AllocateOneByteConsString(Register result, Register scratch1,
1211 Register scratch2, Label* gc_required);
1215 void AllocateTwoByteSlicedString(Register result,
1216 Register scratch1,
1217 Register scratch2,
1219 void AllocateOneByteSlicedString(Register result, Register scratch1,
1220 Register scratch2, Label* gc_required);
1226 void NegativeZeroTest(Register result, Register op, Label* then_label);
1230 Register result,
1231 Register op,
1235 // Register scratch is destroyed, and it must be different from op2.
1236 void NegativeZeroTest(Register result, Register op1, Register op2,
1237 Register scratch, Label* then_label);
1244 void TryGetFunctionPrototype(Register function,
1245 Register result,
1250 // Register use:
1253 void IndexFromHash(Register hash, Register index);
1256 void LoadContext(Register dst, int context_chain_length);
1265 Register map_in_out,
1266 Register scratch,
1270 void LoadGlobalFunction(int index, Register function);
1274 void LoadGlobalFunctionInitialMap(Register function, Register map);
1336 void CallApiFunctionAndReturn(Register function_address,
1338 Register thunk_last_arg,
1358 void CallCFunction(Register function, int num_arguments);
1371 void Ret(int bytes_dropped, Register scratch);
1384 void CopyBytes(Register destination,
1385 Register source,
1386 Register length,
1388 Register scratch = kScratchRegister);
1393 void InitializeFieldsWithFiller(Register start_offset,
1394 Register end_offset,
1395 Register filler);
1400 void TruncatingDiv(Register dividend, int32_t divisor);
1417 void AssertFastElements(Register elements);
1435 static int SafepointRegisterStackIndex(Register reg) {
1445 void CheckEnumCache(Register null_value,
1454 void TestJSArrayForAllocationMemento(Register receiver_reg,
1455 Register scratch_reg,
1458 void JumpIfJSArrayHasAllocationMemento(Register receiver_reg,
1459 Register scratch_reg,
1469 void JumpIfDictionaryInPrototypeChain(Register object, Register scratch0,
1470 Register scratch1, Label* found);
1475 static const int kSafepointPushRegisterIndices[Register::kNumRegisters];
1485 Register GetSmiConstant(Smi* value);
1490 void LoadSmiConstant(Register dst, Smi* value);
1499 Register code_register,
1518 void LoadAllocationTopHelper(Register result,
1519 Register scratch,
1522 void MakeSureDoubleAlignedHelper(Register result,
1523 Register scratch,
1529 void UpdateAllocationTopHelper(Register result_end,
1530 Register scratch,
1534 void InNewSpace(Register object,
1535 Register scratch,
1544 inline void GetMarkBits(Register addr_reg,
1545 Register bitmap_reg,
1546 Register mask_reg);
1553 Operand SafepointRegisterSlot(Register reg);
1588 inline Operand FieldOperand(Register object, int offset) {
1594 inline Operand FieldOperand(Register object,
1595 Register index,
1602 inline Operand ContextOperand(Register context, int index) {