Lines Matching refs:Register
18 V(Ldrb, Register&, rt, LDRB_w) \
19 V(Strb, Register&, rt, STRB_w) \
20 V(Ldrsb, Register&, rt, rt.Is64Bits() ? LDRSB_x : LDRSB_w) \
21 V(Ldrh, Register&, rt, LDRH_w) \
22 V(Strh, Register&, rt, STRH_w) \
23 V(Ldrsh, Register&, rt, rt.Is64Bits() ? LDRSH_x : LDRSH_w) \
26 V(Ldrsw, Register&, rt, LDRSW_x)
33 inline MemOperand FieldMemOperand(Register object, int offset);
34 inline MemOperand UntagSmiFieldMemOperand(Register object, int offset);
37 inline MemOperand UntagSmiMemOperand(Register object, int offset);
115 inline void And(const Register& rd,
116 const Register& rn,
118 inline void Ands(const Register& rd,
119 const Register& rn,
121 inline void Bic(const Register& rd,
122 const Register& rn,
124 inline void Bics(const Register& rd,
125 const Register& rn,
127 inline void Orr(const Register& rd,
128 const Register& rn,
130 inline void Orn(const Register& rd,
131 const Register& rn,
133 inline void Eor(const Register& rd,
134 const Register& rn,
136 inline void Eon(const Register& rd,
137 const Register& rn,
139 inline void Tst(const Register& rn, const Operand& operand);
140 void LogicalMacro(const Register& rd,
141 const Register& rn,
146 inline void Add(const Register& rd,
147 const Register& rn,
149 inline void Adds(const Register& rd,
150 const Register& rn,
152 inline void Sub(const Register& rd,
153 const Register& rn,
155 inline void Subs(const Register& rd,
156 const Register& rn,
158 inline void Cmn(const Register& rn, const Operand& operand);
159 inline void Cmp(const Register& rn, const Operand& operand);
160 inline void Neg(const Register& rd,
162 inline void Negs(const Register& rd,
165 void AddSubMacro(const Register& rd,
166 const Register& rn,
172 inline void Adc(const Register& rd,
173 const Register& rn,
175 inline void Adcs(const Register& rd,
176 const Register& rn,
178 inline void Sbc(const Register& rd,
179 const Register& rn,
181 inline void Sbcs(const Register& rd,
182 const Register& rn,
184 inline void Ngc(const Register& rd,
186 inline void Ngcs(const Register& rd,
188 void AddSubWithCarryMacro(const Register& rd,
189 const Register& rn,
195 void Mov(const Register& rd,
198 void Mov(const Register& rd, uint64_t imm);
199 inline void Mvn(const Register& rd, uint64_t imm);
200 void Mvn(const Register& rd, const Operand& operand);
206 inline void Ccmp(const Register& rn,
210 inline void Ccmn(const Register& rn,
214 void ConditionalCompareMacro(const Register& rn,
219 void Csel(const Register& rd,
220 const Register& rn,
235 void Load(const Register& rt, const MemOperand& addr, Representation r);
236 void Store(const Register& rt, const MemOperand& addr, Representation r);
245 void Adr(const Register& rd, Label* label, AdrHint = kAdrNear);
248 inline void Asr(const Register& rd, const Register& rn, unsigned shift);
249 inline void Asr(const Register& rd, const Register& rn, const Register& rm);
256 void B(Label* label, BranchType type, Register reg = NoReg, int bit = -1);
261 inline void Bfi(const Register& rd,
262 const Register& rn,
265 inline void Bfxil(const Register& rd,
266 const Register& rn,
271 inline void Blr(const Register& xn);
272 inline void Br(const Register& xn);
274 void Cbnz(const Register& rt, Label* label);
275 void Cbz(const Register& rt, Label* label);
276 inline void Cinc(const Register& rd, const Register& rn, Condition cond);
277 inline void Cinv(const Register& rd, const Register& rn, Condition cond);
278 inline void Cls(const Register& rd, const Register& rn);
279 inline void Clz(const Register& rd, const Register& rn);
280 inline void Cneg(const Register& rd, const Register& rn, Condition cond);
281 inline void CzeroX(const Register& rd, Condition cond);
282 inline void CmovX(const Register& rd, const Register& rn, Condition cond);
283 inline void Cset(const Register& rd, Condition cond);
284 inline void Csetm(const Register& rd, Condition cond);
285 inline void Csinc(const Register& rd,
286 const Register& rn,
287 const Register& rm,
289 inline void Csinv(const Register& rd,
290 const Register& rn,
291 const Register& rm,
293 inline void Csneg(const Register& rd,
294 const Register& rn,
295 const Register& rm,
300 inline void Extr(const Register& rd,
301 const Register& rn,
302 const Register& rm,
319 inline void Fcvtas(const Register& rd, const FPRegister& fn);
320 inline void Fcvtau(const Register& rd, const FPRegister& fn);
321 inline void Fcvtms(const Register& rd, const FPRegister& fn);
322 inline void Fcvtmu(const Register& rd, const FPRegister& fn);
323 inline void Fcvtns(const Register& rd, const FPRegister& fn);
324 inline void Fcvtnu(const Register& rd, const FPRegister& fn);
325 inline void Fcvtzs(const Register& rd, const FPRegister& fn);
326 inline void Fcvtzu(const Register& rd, const FPRegister& fn);
347 inline void Fmov(FPRegister fd, Register rn);
360 inline void Fmov(Register rd, FPRegister fn);
394 inline void Ldpsw(const Register& rt,
395 const Register& rt2,
401 inline void Lsl(const Register& rd, const Register& rn, unsigned shift);
402 inline void Lsl(const Register& rd, const Register& rn, const Register& rm);
403 inline void Lsr(const Register& rd, const Register& rn, unsigned shift);
404 inline void Lsr(const Register& rd, const Register& rn, const Register& rm);
405 inline void Madd(const Register& rd,
406 const Register& rn,
407 const Register& rm,
408 const Register& ra);
409 inline void Mneg(const Register& rd, const Register& rn, const Register& rm);
410 inline void Mov(const Register& rd, const Register& rm);
411 inline void Movk(const Register& rd, uint64_t imm, int shift = -1);
412 inline void Mrs(const Register& rt, SystemRegister sysreg);
413 inline void Msr(SystemRegister sysreg, const Register& rt);
414 inline void Msub(const Register& rd,
415 const Register& rn,
416 const Register& rm,
417 const Register& ra);
418 inline void Mul(const Register& rd, const Register& rn, const Register& rm);
420 inline void Rbit(const Register& rd, const Register& rn);
421 inline void Ret(const Register& xn = lr);
422 inline void Rev(const Register& rd, const Register& rn);
423 inline void Rev16(const Register& rd, const Register& rn);
424 inline void Rev32(const Register& rd, const Register& rn);
425 inline void Ror(const Register& rd, const Register& rs, unsigned shift);
426 inline void Ror(const Register& rd, const Register& rn, const Register& rm);
427 inline void Sbfiz(const Register& rd,
428 const Register& rn,
431 inline void Sbfx(const Register& rd,
432 const Register& rn,
436 const Register& rn,
438 inline void Sdiv(const Register& rd, const Register& rn, const Register& rm);
439 inline void Smaddl(const Register& rd,
440 const Register& rn,
441 const Register& rm,
442 const Register& ra);
443 inline void Smsubl(const Register& rd,
444 const Register& rn,
445 const Register& rm,
446 const Register& ra);
447 inline void Smull(const Register& rd,
448 const Register& rn,
449 const Register& rm);
450 inline void Smulh(const Register& rd,
451 const Register& rn,
452 const Register& rm);
459 inline void Sxtb(const Register& rd, const Register& rn);
460 inline void Sxth(const Register& rd, const Register& rn);
461 inline void Sxtw(const Register& rd, const Register& rn);
462 void Tbnz(const Register& rt, unsigned bit_pos, Label* label);
463 void Tbz(const Register& rt, unsigned bit_pos, Label* label);
464 inline void Ubfiz(const Register& rd,
465 const Register& rn,
468 inline void Ubfx(const Register& rd,
469 const Register& rn,
473 const Register& rn,
475 inline void Udiv(const Register& rd, const Register& rn, const Register& rm);
476 inline void Umaddl(const Register& rd,
477 const Register& rn,
478 const Register& rm,
479 const Register& ra);
480 inline void Umsubl(const Register& rd,
481 const Register& rn,
482 const Register& rm,
483 const Register& ra);
484 inline void Uxtb(const Register& rd, const Register& rn);
485 inline void Uxth(const Register& rd, const Register& rn);
486 inline void Uxtw(const Register& rd, const Register& rn);
496 void Abs(const Register& rd, const Register& rm,
582 void PushMultipleTimes(CPURegister src, Register count);
590 inline void push(Register src) {
593 inline void pop(Register dst) {
667 // Register count, the unit size must be a power of two.
669 inline void Claim(const Register& count,
672 inline void Drop(const Register& count,
677 inline void ClaimBySMI(const Register& count_smi,
679 inline void DropBySMI(const Register& count_smi,
684 inline void CompareAndBranch(const Register& lhs,
691 inline void TestAndBranchIfAnySet(const Register& reg,
697 inline void TestAndBranchIfAllClear(const Register& reg,
760 inline void SetStackPointer(const Register& stack_pointer) {
766 inline const Register& StackPointer() const {
807 void AssertFPCRState(Register fpcr = NoReg);
818 void StoreRoot(Register source,
822 void LoadTrueFalseRoots(Register true_root, Register false_root);
824 void LoadHeapObject(Register dst, Handle<HeapObject> object);
826 void LoadObject(Register result, Handle<Object> object) {
840 inline void Move(Register dst, Register src) { Mov(dst, src); }
842 void LoadInstanceDescriptors(Register map,
843 Register descriptors);
844 void EnumLengthUntagged(Register dst, Register map);
845 void EnumLengthSmi(Register dst, Register map);
846 void NumberOfOwnDescriptors(Register dst, Register map);
849 void DecodeField(Register dst, Register src) {
856 void DecodeField(Register reg) {
862 inline void SmiTag(Register dst, Register src);
863 inline void SmiTag(Register smi);
864 inline void SmiUntag(Register dst, Register src);
865 inline void SmiUntag(Register smi);
867 Register src,
870 Register src,
874 inline void SmiTagAndPush(Register src);
875 inline void SmiTagAndPush(Register src1, Register src2);
880 void SmiAbs(const Register& smi, Label* slow);
882 inline void JumpIfSmi(Register value,
885 inline void JumpIfNotSmi(Register value, Label* not_smi_label);
886 inline void JumpIfBothSmi(Register value1,
887 Register value2,
890 inline void JumpIfEitherSmi(Register value1,
891 Register value2,
894 inline void JumpIfEitherNotSmi(Register value1,
895 Register value2,
897 inline void JumpIfBothNotSmi(Register value1,
898 Register value2,
902 void AssertNotSmi(Register object, BailoutReason reason = kOperandIsASmi);
903 void AssertSmi(Register object, BailoutReason reason = kOperandIsNotASmi);
905 inline void ObjectTag(Register tagged_obj, Register obj);
906 inline void ObjectUntag(Register untagged_obj, Register obj);
909 void AssertName(Register object);
913 void AssertUndefinedOrAllocationSite(Register object, Register scratch);
916 void AssertString(Register object);
918 void JumpForHeapNumber(Register object,
919 Register heap_number_map,
922 void JumpIfHeapNumber(Register object,
924 Register heap_number_map = NoReg);
925 void JumpIfNotHeapNumber(Register object,
927 Register heap_number_map = NoReg);
937 void JumpIfMinusZero(Register input, Label* on_negative_zero);
944 void LookupNumberStringCache(Register object,
945 Register result,
946 Register scratch1,
947 Register scratch2,
948 Register scratch3,
953 void ClampInt32ToUint8(Register in_out);
954 void ClampInt32ToUint8(Register output, Register input);
957 void ClampDoubleToUint8(Register output,
966 void TryRepresentDoubleAsInt32(Register as_int,
981 void TryRepresentDoubleAsInt64(Register as_int,
1002 void CopyFields(Register dst, Register src, CPURegList temps, unsigned count);
1005 // 64-bit value in register filler. Register dst is corrupted.
1006 void FillFields(Register dst,
1007 Register field_count,
1008 Register filler);
1014 void CopyBytes(Register dst,
1015 Register src,
1016 Register length,
1017 Register scratch,
1026 Register first,
1027 Register second,
1028 Register scratch1,
1029 Register scratch2,
1035 void JumpIfInstanceTypeIsNotSequentialAscii(Register type,
1036 Register scratch,
1042 Register first_object_instance_type,
1043 Register second_object_instance_type,
1044 Register scratch1,
1045 Register scratch2,
1051 Register first_object_instance_type,
1052 Register second_object_instance_type,
1053 Register scratch1,
1054 Register scratch2,
1057 void JumpIfNotUniqueName(Register type, Label* not_unique_name);
1065 // Register value must be x0.
1066 void Throw(Register value,
1067 Register scratch1,
1068 Register scratch2,
1069 Register scratch3,
1070 Register scratch4);
1073 // handler chain. Register value must be x0.
1074 void ThrowUncatchable(Register value,
1075 Register scratch1,
1076 Register scratch2,
1077 Register scratch3,
1078 Register scratch4);
1114 void CallCFunction(Register function,
1124 void CallApiFunctionAndReturn(Register function_address,
1156 void GetBuiltinEntry(Register target,
1157 Register function,
1161 void GetBuiltinFunction(Register target, Builtins::JavaScript id);
1163 void Jump(Register target);
1168 void Call(Register target);
1177 static int CallSize(Register target);
1194 Register code_reg,
1199 void InvokeCode(Register code,
1206 void InvokeFunction(Register function,
1210 void InvokeFunction(Register function,
1233 void TryConvertDoubleToInt64(Register result,
1240 void TruncateDoubleToI(Register result, DoubleRegister double_input);
1245 void TruncateHeapNumberToI(Register result, Register object);
1251 void TruncateNumberToI(Register object,
1252 Register result,
1253 Register heap_number_map,
1311 void Allocate(Register object_size,
1312 Register result,
1313 Register scratch1,
1314 Register scratch2,
1319 Register result,
1320 Register scratch1,
1321 Register scratch2,
1329 void UndoAllocationInNewSpace(Register object, Register scratch);
1331 void AllocateTwoByteString(Register result,
1332 Register length,
1333 Register scratch1,
1334 Register scratch2,
1335 Register scratch3,
1337 void AllocateAsciiString(Register result,
1338 Register length,
1339 Register scratch1,
1340 Register scratch2,
1341 Register scratch3,
1343 void AllocateTwoByteConsString(Register result,
1344 Register length,
1345 Register scratch1,
1346 Register scratch2,
1348 void AllocateAsciiConsString(Register result,
1349 Register length,
1350 Register scratch1,
1351 Register scratch2,
1353 void AllocateTwoByteSlicedString(Register result,
1354 Register length,
1355 Register scratch1,
1356 Register scratch2,
1358 void AllocateAsciiSlicedString(Register result,
1359 Register length,
1360 Register scratch1,
1361 Register scratch2,
1369 void AllocateHeapNumber(Register result,
1371 Register scratch1,
1372 Register scratch2,
1388 void TryGetFunctionPrototype(Register function,
1389 Register result,
1390 Register scratch,
1402 void CompareObjectType(Register heap_object,
1403 Register map,
1404 Register type_reg,
1415 void JumpIfObjectType(Register object,
1416 Register map,
1417 Register type_reg,
1422 void JumpIfNotObjectType(Register object,
1423 Register map,
1424 Register type_reg,
1431 void CompareInstanceType(Register map,
1432 Register type_reg,
1437 void CompareMap(Register obj,
1438 Register scratch,
1443 void CompareMap(Register obj_map,
1450 void CheckMap(Register obj,
1451 Register scratch,
1457 void CheckMap(Register obj,
1458 Register scratch,
1465 void CheckMap(Register obj_map,
1473 void DispatchMap(Register obj,
1474 Register scratch,
1481 void TestMapBitfield(Register object, uint64_t mask);
1485 void LoadElementsKindFromMap(Register result, Register map);
1488 void CompareRoot(const Register& obj, Heap::RootListIndex index);
1491 void JumpIfRoot(const Register& obj,
1496 void JumpIfNotRoot(const Register& obj,
1505 inline void IsObjectNameType(Register object, Register type, Label* fail);
1507 inline void IsObjectJSObjectType(Register heap_object,
1508 Register map,
1509 Register scratch,
1517 inline void IsInstanceJSObjectType(Register map,
1518 Register scratch,
1527 inline void IsObjectJSStringType(Register object, Register type,
1532 void CompareAndSplit(const Register& lhs,
1541 void TestAndSplit(const Register& reg,
1549 void CheckFastElements(Register map, Register scratch, Label* fail);
1553 void CheckFastObjectElements(Register map, Register scratch, Label* fail);
1558 void StoreNumberToDoubleElements(Register value_reg,
1559 Register key_reg,
1560 Register elements_reg,
1561 Register scratch1,
1567 // Register use:
1570 void IndexFromHash(Register hash, Register index);
1575 void EmitSeqStringSetCharCheck(Register string,
1576 Register index,
1578 Register scratch,
1584 void CheckAccessGlobalProxy(Register holder_reg,
1585 Register scratch1,
1586 Register scratch2,
1591 void GetNumberHash(Register key, Register scratch);
1606 Register elements,
1607 Register key,
1608 Register result,
1609 Register scratch0,
1610 Register scratch1,
1611 Register scratch2,
1612 Register scratch3);
1622 void CheckEnumCache(Register object,
1623 Register null_value,
1624 Register scratch0,
1625 Register scratch1,
1626 Register scratch2,
1627 Register scratch3,
1636 void TestJSArrayForAllocationMemento(Register receiver,
1637 Register scratch1,
1638 Register scratch2,
1641 void JumpIfJSArrayHasAllocationMemento(Register receiver,
1642 Register scratch1,
1643 Register scratch2,
1687 const Register& scratch,
1701 const Register& scratch,
1704 void LoadContext(Register dst, int context_chain_length);
1708 void TruncatingDiv(Register result, Register dividend, int32_t divisor);
1713 void SetCounter(StatsCounter* counter, int value, Register scratch1,
1714 Register scratch2);
1715 void IncrementCounter(StatsCounter* counter, int value, Register scratch1,
1716 Register scratch2);
1717 void DecrementCounter(StatsCounter* counter, int value, Register scratch1,
1718 Register scratch2);
1731 void RememberedSetHelper(Register object, // Used for debug code.
1732 Register addr,
1733 Register scratch1,
1746 void StoreToSafepointRegisterSlot(Register src, Register dst) {
1752 void LoadFromSafepointRegisterSlot(Register dst, Register src) {
1756 void CheckPageFlagSet(const Register& object,
1757 const Register& scratch,
1761 void CheckPageFlagClear(const Register& object,
1762 const Register& scratch,
1767 Register scratch,
1771 // Register 'object' is preserved.
1772 void JumpIfNotInNewSpace(Register object,
1777 void JumpIfInNewSpace(Register object,
1788 Register object,
1790 Register value,
1791 Register scratch,
1802 Register context,
1804 Register value,
1805 Register scratch,
1824 Register object,
1825 Register map,
1826 Register dst,
1834 Register object,
1835 Register address,
1836 Register value,
1849 void EnsureNotWhite(Register object,
1850 Register scratch1,
1851 Register scratch2,
1852 Register scratch3,
1853 Register scratch4,
1858 void JumpIfDataObject(Register value,
1859 Register scratch,
1869 inline void GetMarkBits(Register addr_reg,
1870 Register bitmap_reg,
1871 Register shift_reg);
1874 void HasColor(Register object,
1875 Register scratch0,
1876 Register scratch1,
1881 void JumpIfBlack(Register object,
1882 Register scratch0,
1883 Register scratch1,
1889 void GetRelocatedValueLocation(Register ldr_location,
1890 Register result);
1899 void AssertRegisterIsClear(Register reg, BailoutReason reason);
1901 Register reg,
1904 void AssertFastElements(Register elements);
1910 void AssertHasValidColor(const Register& reg);
1915 void AssertIsString(const Register& object);
1919 void CheckRegisterIsClear(Register reg, BailoutReason reason);
1931 Register map_in_out,
1932 Register scratch1,
1933 Register scratch2,
1936 void LoadGlobalFunction(int index, Register function);
1940 void LoadGlobalFunctionInitialMap(Register function,
1941 Register map,
1942 Register scratch);
2025 void JumpIfDictionaryInPrototypeChain(Register object, Register scratch0,
2026 Register scratch1, Label* found);
2040 void CopyFieldsLoopPairsHelper(Register dst, Register src, unsigned count,
2041 Register scratch1, Register scratch2,
2042 Register scratch3, Register scratch4,
2043 Register scratch5);
2044 void CopyFieldsUnrolledPairsHelper(Register dst, Register src, unsigned count,
2045 Register scratch1, Register scratch2,
2046 Register scratch3, Register scratch4);
2047 void CopyFieldsUnrolledHelper(Register dst, Register src, unsigned count,
2048 Register scratch1, Register scratch2,
2049 Register scratch3);
2076 void JumpToHandlerEntry(Register exception,
2077 Register object,
2078 Register state,
2079 Register scratch1,
2080 Register scratch2);
2083 void InNewSpace(Register object,
2096 void TryRepresentDoubleAsInt(Register as_int,
2123 Register sp_;
2129 void InitializeNewString(Register string,
2130 Register length,
2132 Register scratch1,
2133 Register scratch2);
2231 Register AcquireW() { return AcquireNextAvailable(available_).W(); }
2232 Register AcquireX() { return AcquireNextAvailable(available_).X(); }
2236 Register UnsafeAcquire(const Register& reg) {
2237 return Register(UnsafeAcquire(available_, reg));
2240 Register AcquireSameSizeAs(const Register& reg);
2258 inline MemOperand ContextMemOperand(Register context, int index) {
2276 const Register& SmiRegister() const {
2290 static void Emit(MacroAssembler* masm, const Register& reg,
2300 Register reg_;