Lines Matching refs:Register
16 const Register kReturnRegister0 = {Register::kCode_v0};
17 const Register kReturnRegister1 = {Register::kCode_v1};
18 const Register kReturnRegister2 = {Register::kCode_a0};
19 const Register kJSFunctionRegister = {Register::kCode_a1};
20 const Register kContextRegister = {Register::kCpRegister};
21 const Register kAllocateSizeRegister = {Register::kCode_a0};
22 const Register kInterpreterAccumulatorRegister = {Register::kCode_v0};
23 const Register kInterpreterBytecodeOffsetRegister = {Register::kCode_t0};
24 const Register kInterpreterBytecodeArrayRegister = {Register::kCode_t1};
25 const Register kInterpreterDispatchTableRegister = {Register::kCode_t2};
26 const Register kJavaScriptCallArgCountRegister = {Register::kCode_a0};
27 const Register kJavaScriptCallNewTargetRegister = {Register::kCode_a3};
28 const Register kRuntimeCallFunctionRegister = {Register::kCode_a1};
29 const Register kRuntimeCallArgCountRegister = {Register::kCode_a0};
102 Register GetRegisterThatIsNotOneOf(Register reg1,
103 Register reg2 = no_reg,
104 Register reg3 = no_reg,
105 Register reg4 = no_reg,
106 Register reg5 = no_reg,
107 Register reg6 = no_reg);
109 bool AreAliased(Register reg1, Register reg2, Register reg3 = no_reg,
110 Register reg4 = no_reg, Register reg5 = no_reg,
111 Register reg6 = no_reg, Register reg7 = no_reg,
112 Register reg8 = no_reg, Register reg9 = no_reg,
113 Register reg10 = no_reg);
126 inline MemOperand ContextMemOperand(Register context, int index) { in ContextMemOperand()
137 inline MemOperand FieldMemOperand(Register object, int offset) { in FieldMemOperand()
142 inline MemOperand UntagSmiMemOperand(Register rm, int offset) { in UntagSmiMemOperand()
149 inline MemOperand UntagSmiFieldMemOperand(Register rm, int offset) { in UntagSmiFieldMemOperand()
174 #define COND_TYPED_ARGS Condition cond, Register r1, const Operand& r2
206 #define COND_ARGS Condition cond = al, Register rs = zero_reg, \
209 void Jump(Register target, COND_ARGS);
213 static int CallSize(Register target, COND_ARGS);
214 void Call(Register target, COND_ARGS);
227 Register rs = zero_reg, const Operand& rt = Operand(zero_reg)) {
235 Register rs,
249 void GenerateSwitchTable(Register index, size_t case_count,
259 Register reg, typename Descriptor::ParameterIndices parameter_index,
269 Register reg = no_reg,
278 Register reg,
283 void Swap(Register reg1, Register reg2, Register scratch = no_reg);
287 inline void Move(Register dst, Handle<Object> handle) { li(dst, handle); } in Move()
288 inline void Move(Register dst, Smi* smi) { li(dst, Operand(smi)); } in Move()
290 inline void Move(Register dst, Register src) { in Move()
310 inline void Move(Register dst_low, Register dst_high, FPURegister src) { in Move()
315 inline void Move(Register dst, FPURegister src) { dmfc1(dst, src); } in Move()
317 inline void Move(FPURegister dst, Register src) { dmtc1(src, dst); } in Move()
319 inline void FmoveHigh(Register dst_high, FPURegister src) { in FmoveHigh()
323 inline void FmoveHigh(FPURegister dst, Register src_high) { in FmoveHigh()
327 inline void FmoveLow(Register dst_low, FPURegister src) { in FmoveLow()
331 void FmoveLow(FPURegister dst, Register src_low);
333 inline void Move(FPURegister dst, Register src_low, Register src_high) { in Move()
342 void Movz(Register rd, Register rs, Register rt);
343 void Movn(Register rd, Register rs, Register rt);
344 void Movt(Register rd, Register rs, uint16_t cc = 0);
345 void Movf(Register rd, Register rs, uint16_t cc = 0);
347 void Clz(Register rd, Register rs);
358 void Load(Register dst, const MemOperand& src, Representation r);
359 void Store(Register src, const MemOperand& dst, Representation r);
367 void JumpIfRoot(Register with, Heap::RootListIndex index, Label* if_equal) { in JumpIfRoot()
373 void JumpIfNotRoot(Register with, Heap::RootListIndex index, in JumpIfNotRoot()
380 void LoadRoot(Register destination,
382 void LoadRoot(Register destination,
384 Condition cond, Register src1, const Operand& src2);
387 void StoreRoot(Register source,
389 void StoreRoot(Register source,
391 Condition cond, Register src1, const Operand& src2);
396 void IncrementalMarkingRecordWriteHelper(Register object,
397 Register value,
398 Register address);
409 void RememberedSetHelper(Register object, // Used for debug code.
410 Register addr,
411 Register scratch,
415 void CheckPageFlag(Register object,
416 Register scratch,
423 void JumpIfNotInNewSpace(Register object, in JumpIfNotInNewSpace()
424 Register scratch, in JumpIfNotInNewSpace()
431 void JumpIfInNewSpace(Register object, in JumpIfInNewSpace()
432 Register scratch, in JumpIfInNewSpace()
438 void HasColor(Register object,
439 Register scratch0,
440 Register scratch1,
445 void JumpIfBlack(Register object,
446 Register scratch0,
447 Register scratch1,
452 void JumpIfWhite(Register value, Register scratch1, Register scratch2,
453 Register scratch3, Label* value_is_white);
461 Register object,
463 Register value,
464 Register scratch,
475 Register context,
477 Register value,
478 Register scratch,
498 void RecordWriteCodeEntryField(Register js_function, Register code_entry,
499 Register scratch);
502 Register object,
503 Register map,
504 Register dst,
512 Register object,
513 Register address,
514 Register value,
526 void GetNumberHash(Register reg0, Register scratch);
573 Register result,
574 Register scratch1,
575 Register scratch2,
579 void Allocate(Register object_size, Register result, Register result_end,
580 Register scratch, Label* gc_required, AllocationFlags flags);
585 void FastAllocate(int object_size, Register result, Register scratch1,
586 Register scratch2, AllocationFlags flags);
588 void FastAllocate(Register object_size, Register result, Register result_new,
589 Register scratch, AllocationFlags flags);
594 void AllocateHeapNumber(Register result,
595 Register scratch1,
596 Register scratch2,
597 Register heap_number_map,
601 void AllocateHeapNumberWithValue(Register result,
603 Register scratch1,
604 Register scratch2,
609 void AllocateJSValue(Register result, Register constructor, Register value,
610 Register scratch1, Register scratch2,
617 void instr(Register rd, Register rs, const Operand& rt); \
618 void instr(Register rd, Register rs, Register rt) { \
621 void instr(Register rs, Register rt, int32_t j) { \
626 void instr(Register rs, const Operand& rt); \
627 void instr(Register rs, Register rt) { \
630 void instr(Register rs, int32_t j) { \
680 void Lsa(Register rd, Register rs, Register rt, uint8_t sa,
681 Register scratch = at);
682 void Dlsa(Register rd, Register rs, Register rt, uint8_t sa,
683 Register scratch = at);
692 void ByteSwapSigned(Register dest, Register src, int operand_size);
693 void ByteSwapUnsigned(Register dest, Register src, int operand_size);
695 void mov(Register rd, Register rt) { or_(rd, rt, zero_reg); } in mov()
697 void Ulh(Register rd, const MemOperand& rs);
698 void Ulhu(Register rd, const MemOperand& rs);
699 void Ush(Register rd, const MemOperand& rs, Register scratch);
701 void Ulw(Register rd, const MemOperand& rs);
702 void Ulwu(Register rd, const MemOperand& rs);
703 void Usw(Register rd, const MemOperand& rs);
705 void Uld(Register rd, const MemOperand& rs);
706 void Usd(Register rd, const MemOperand& rs);
708 void Ulwc1(FPURegister fd, const MemOperand& rs, Register scratch);
709 void Uswc1(FPURegister fd, const MemOperand& rs, Register scratch);
711 void Uldc1(FPURegister fd, const MemOperand& rs, Register scratch);
712 void Usdc1(FPURegister fd, const MemOperand& rs, Register scratch);
714 void LoadWordPair(Register rd, const MemOperand& rs, Register scratch = at);
715 void StoreWordPair(Register rd, const MemOperand& rs, Register scratch = at);
718 void li(Register rd, Operand j, LiFlags mode = OPTIMIZE_SIZE);
719 inline bool LiLower32BitHelper(Register rd, Operand j);
720 inline void li(Register rd, int64_t j, LiFlags mode = OPTIMIZE_SIZE) {
723 void li(Register dst, Handle<Object> value, LiFlags mode = OPTIMIZE_SIZE);
734 void push(Register src) { in push()
738 void Push(Register src) { push(src); } in Push()
745 void Push(Register src1, Register src2) { in Push()
752 void Push(Register src1, Register src2, Register src3) { in Push()
760 void Push(Register src1, Register src2, Register src3, Register src4) { in Push()
769 void Push(Register src1, Register src2, Register src3, Register src4, in Push()
770 Register src5) { in Push()
779 void Push(Register src, Condition cond, Register tst1, Register tst2) { in Push()
786 void PushRegisterAsTwoSmis(Register src, Register scratch = at);
787 void PopRegisterAsTwoSmis(Register dst, Register scratch = at);
797 void pop(Register dst) { in pop()
801 void Pop(Register dst) { pop(dst); } in Pop()
804 void Pop(Register src1, Register src2) { in Pop()
812 void Pop(Register src1, Register src2, Register src3) { in Pop()
824 void PushCommonFrame(Register marker_reg = no_reg);
827 void PushStandardFrame(Register function_reg);
829 void PopCommonFrame(Register marker_reg = no_reg);
837 void StoreToSafepointRegisterSlot(Register src, Register dst);
840 void LoadFromSafepointRegisterSlot(Register dst, Register src);
843 void Ins(Register rt, Register rs, uint16_t pos, uint16_t size);
844 void Dins(Register rt, Register rs, uint16_t pos, uint16_t size);
845 void Ext(Register rt, Register rs, uint16_t pos, uint16_t size);
847 void ExtractBits(Register rt, Register rs, uint16_t pos, uint16_t size);
849 void Dext(Register rt, Register rs, uint16_t pos, uint16_t size);
850 void Dextm(Register rt, Register rs, uint16_t pos, uint16_t size);
851 void Dextu(Register rt, Register rs, uint16_t pos, uint16_t size);
856 void Bovc(Register rt, Register rs, Label* L);
857 void Bnvc(Register rt, Register rs, Label* L);
864 void Cvt_d_uw(FPURegister fd, Register rs);
868 void Cvt_d_ul(FPURegister fd, Register rs);
872 void Cvt_s_uw(FPURegister fd, Register rs);
876 void Cvt_s_ul(FPURegister fd, Register rs);
888 void Trunc_uw_d(FPURegister fd, Register rs, FPURegister scratch);
892 void Trunc_uw_s(FPURegister fd, Register rs, FPURegister scratch);
896 Register result = no_reg);
897 void Trunc_ul_d(FPURegister fd, Register rs, FPURegister scratch,
898 Register result = no_reg);
902 Register result = no_reg);
903 void Trunc_ul_s(FPURegister fd, Register rs, FPURegister scratch,
904 Register result = no_reg);
967 Register result,
969 Register scratch,
971 Register except_flag,
981 void TryInlineTruncateDoubleToI(Register result,
988 void TruncateDoubleToI(Register result, DoubleRegister double_input);
993 void TruncateHeapNumberToI(Register result, Register object);
999 void TruncateNumberToI(Register object,
1000 Register result,
1001 Register heap_number_map,
1002 Register scratch,
1008 void LoadNumber(Register object,
1010 Register heap_number_map,
1011 Register scratch,
1019 void LoadNumberAsInt32Double(Register object,
1021 Register heap_number_map,
1022 Register scratch1,
1023 Register scratch2,
1032 void LoadNumberAsInt32(Register object,
1033 Register dst,
1034 Register heap_number_map,
1035 Register scratch1,
1036 Register scratch2,
1049 void LeaveExitFrame(bool save_doubles, Register arg_count,
1059 void LoadContext(Register dst, int context_chain_length);
1062 void LoadGlobalObject(Register dst) { in LoadGlobalObject()
1067 void LoadGlobalProxy(Register dst) { in LoadGlobalProxy()
1071 void LoadNativeContextSlot(int index, Register dst);
1075 void LoadGlobalFunctionInitialMap(Register function,
1076 Register map,
1077 Register scratch);
1094 Register caller_args_count_reg, Register scratch0,
1095 Register scratch1);
1098 void InvokeFunctionCode(Register function, Register new_target,
1104 void CheckDebugHook(Register fun, Register new_target,
1110 void InvokeFunction(Register function,
1111 Register new_target,
1116 void InvokeFunction(Register function,
1129 void IsObjectJSStringType(Register object,
1130 Register scratch,
1133 void IsObjectNameType(Register object,
1134 Register scratch,
1152 void InitializeFieldsWithFiller(Register current_address,
1153 Register end_address, Register filler);
1160 void GetMapConstructor(Register result, Register map, Register temp,
1161 Register temp2);
1163 void GetObjectType(Register function,
1164 Register map,
1165 Register type_reg);
1167 void GetInstanceType(Register object_map, Register object_instance_type) { in GetInstanceType()
1176 void CompareMapAndBranch(Register obj,
1177 Register scratch,
1185 void CompareMapAndBranch(Register obj_map,
1195 void CheckMap(Register obj,
1196 Register scratch,
1202 void CheckMap(Register obj,
1203 Register scratch,
1211 void DispatchWeakMap(Register obj, Register scratch1, Register scratch2,
1220 void GetWeakValue(Register value, Handle<WeakCell> cell);
1224 void LoadWeakValue(Register value, Handle<WeakCell> cell, Label* miss);
1229 Condition IsObjectStringType(Register obj, in IsObjectStringType()
1230 Register type, in IsObjectStringType()
1231 Register result) { in IsObjectStringType()
1240 void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
1241 void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
1247 Register object,
1249 Register scratch1,
1250 Register scratch2,
1251 Register heap_number_map,
1258 void SmiToDoubleFPURegister(Register smi,
1260 Register scratch1);
1267 inline void AddBranchOvf(Register dst, Register left, const Operand& right,
1268 Label* overflow_label, Register scratch = at) {
1272 inline void AddBranchNoOvf(Register dst, Register left, const Operand& right,
1273 Label* no_overflow_label, Register scratch = at) {
1277 void AddBranchOvf(Register dst, Register left, const Operand& right,
1279 Register scratch = at);
1281 void AddBranchOvf(Register dst, Register left, Register right,
1283 Register scratch = at);
1285 inline void SubBranchOvf(Register dst, Register left, const Operand& right,
1286 Label* overflow_label, Register scratch = at) {
1290 inline void SubBranchNoOvf(Register dst, Register left, const Operand& right,
1291 Label* no_overflow_label, Register scratch = at) {
1295 void SubBranchOvf(Register dst, Register left, const Operand& right,
1297 Register scratch = at);
1299 void SubBranchOvf(Register dst, Register left, Register right,
1301 Register scratch = at);
1303 inline void MulBranchOvf(Register dst, Register left, const Operand& right,
1304 Label* overflow_label, Register scratch = at) {
1308 inline void MulBranchNoOvf(Register dst, Register left, const Operand& right,
1309 Label* no_overflow_label, Register scratch = at) {
1313 void MulBranchOvf(Register dst, Register left, const Operand& right,
1315 Register scratch = at);
1317 void MulBranchOvf(Register dst, Register left, Register right,
1319 Register scratch = at);
1321 inline void DaddBranchOvf(Register dst, Register left, const Operand& right,
1322 Label* overflow_label, Register scratch = at) {
1326 inline void DaddBranchNoOvf(Register dst, Register left, const Operand& right,
1327 Label* no_overflow_label, Register scratch = at) {
1331 void DaddBranchOvf(Register dst, Register left, const Operand& right,
1333 Register scratch = at);
1335 void DaddBranchOvf(Register dst, Register left, Register right,
1337 Register scratch = at);
1339 inline void DsubBranchOvf(Register dst, Register left, const Operand& right,
1340 Label* overflow_label, Register scratch = at) {
1344 inline void DsubBranchNoOvf(Register dst, Register left, const Operand& right,
1345 Label* no_overflow_label, Register scratch = at) {
1349 void DsubBranchOvf(Register dst, Register left, const Operand& right,
1351 Register scratch = at);
1353 void DsubBranchOvf(Register dst, Register left, Register right,
1355 Register scratch = at);
1358 Register overflow_check,
1364 Register overflow_check,
1369 void RetOnOverflow(Register overflow_check, BranchDelaySlot bd = PROTECT) {
1373 void RetOnNoOverflow(Register overflow_check, BranchDelaySlot bd = PROTECT) {
1410 #define COND_ARGS Condition cond = al, Register rs = zero_reg, \
1471 Register scratch);
1473 Register scratch);
1485 void CallCFunction(Register function, int num_arguments);
1489 void CallCFunction(Register function,
1521 void TruncatingDiv(Register result, Register dividend, int32_t divisor);
1527 Register scratch1, Register scratch2);
1529 Register scratch1, Register scratch2);
1531 Register scratch1, Register scratch2);
1539 void Assert(Condition cc, BailoutReason reason, Register rs, Operand rt);
1540 void AssertFastElements(Register elements);
1543 void Check(Condition cc, BailoutReason reason, Register rs, Operand rt);
1562 void JumpIfNotPowerOfTwoOrZero(Register reg,
1563 Register scratch,
1570 void SmiTagCheckOverflow(Register reg, Register overflow);
1571 void SmiTagCheckOverflow(Register dst, Register src, Register overflow);
1573 void SmiTag(Register dst, Register src) { in SmiTag()
1583 void SmiTag(Register reg) { in SmiTag()
1590 void TrySmiTag(Register reg, Register scratch, Label* not_a_smi) { in TrySmiTag()
1594 void TrySmiTag(Register dst, in TrySmiTag()
1595 Register src, in TrySmiTag()
1596 Register scratch, in TrySmiTag()
1607 void SmiUntag(Register dst, Register src) { in SmiUntag()
1616 void SmiUntag(Register reg) { in SmiUntag()
1621 void SmiScale(Register dst, Register src, int scale) { in SmiScale()
1632 void SmiLoadUntag(Register dst, MemOperand src);
1634 void SmiLoadScale(Register dst, MemOperand src, int scale);
1637 void SmiLoadWithScale(Register d_smi,
1638 Register d_scaled,
1643 void SmiLoadUntagWithScale(Register d_int,
1644 Register d_scaled,
1650 inline void SmiTst(Register value, Register scratch) { in SmiTst()
1653 inline void NonNegativeSmiTst(Register value, Register scratch) { in NonNegativeSmiTst()
1659 void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case);
1662 void JumpIfSmi(Register value,
1664 Register scratch = at,
1668 void JumpIfNotSmi(Register value,
1670 Register scratch = at,
1674 void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi);
1676 void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi);
1679 void AssertNotNumber(Register object);
1682 void AssertNotSmi(Register object);
1683 void AssertSmi(Register object);
1686 void AssertString(Register object);
1689 void AssertName(Register object);
1692 void AssertFunction(Register object);
1696 void AssertBoundFunction(Register object);
1700 void AssertGeneratorObject(Register object);
1703 void AssertReceiver(Register object);
1707 void AssertUndefinedOrAllocationSite(Register object, Register scratch);
1711 void AssertIsRoot(Register reg, Heap::RootListIndex index);
1716 void JumpIfNotHeapNumber(Register object,
1717 Register heap_number_map,
1718 Register scratch,
1727 Register first_object_instance_type, Register second_object_instance_type,
1728 Register scratch1, Register scratch2, Label* failure);
1730 void JumpIfNotUniqueNameInstanceType(Register reg, Label* not_unique_name);
1732 void EmitSeqStringSetCharCheck(Register string,
1733 Register index,
1734 Register value,
1735 Register scratch,
1740 void JumpIfNonSmisNotBothSequentialOneByteStrings(Register first,
1741 Register second,
1742 Register scratch1,
1743 Register scratch2,
1748 void JumpIfNotBothSequentialOneByteStrings(Register first, Register second,
1749 Register scratch1,
1750 Register scratch2,
1753 void ClampUint8(Register output_reg, Register input_reg);
1755 void ClampDoubleToUint8(Register result_reg,
1760 void LoadInstanceDescriptors(Register map, Register descriptors);
1761 void EnumLength(Register dst, Register map);
1762 void NumberOfOwnDescriptors(Register dst, Register map);
1763 void LoadAccessor(Register dst, Register holder, int accessor_index,
1767 void DecodeField(Register dst, Register src) { in DecodeField()
1772 void DecodeField(Register reg) { in DecodeField()
1777 void DecodeFieldToSmi(Register dst, Register src) { in DecodeFieldToSmi()
1786 void DecodeFieldToSmi(Register reg) { in DecodeFieldToSmi()
1794 void EmitLoadFeedbackVector(Register vector);
1801 void EnterBuiltinFrame(Register context, Register target, Register argc);
1802 void LeaveBuiltinFrame(Register context, Register target, Register argc);
1813 void TestJSArrayForAllocationMemento(Register receiver_reg,
1814 Register scratch_reg,
1820 void CallCFunctionHelper(Register function,
1824 inline Register GetRtAsRegisterHelper(const Operand& rt, Register scratch);
1829 Register rs, const Operand& rt);
1830 bool BranchShortHelper(int16_t offset, Label* L, Condition cond, Register rs,
1832 bool BranchShortCheck(int32_t offset, Label* L, Condition cond, Register rs,
1841 Register rs, const Operand& rt);
1843 Register rs, const Operand& rt,
1846 Register rs, const Operand& rt,
1870 void InNewSpace(Register object, Register scratch,
1877 inline void GetMarkBits(Register addr_reg,
1878 Register bitmap_reg,
1879 Register mask_reg);
1883 MemOperand SafepointRegisterSlot(Register reg);
1884 MemOperand SafepointRegistersAndDoublesSlot(Register reg);
1935 void MacroAssembler::GenerateSwitchTable(Register index, size_t case_count, in GenerateSwitchTable()