Lines Matching refs:Register
18 // Reserved Register Usage Summary.
86 Register GetRegisterThatIsNotOneOf(Register reg1,
87 Register reg2 = no_reg,
88 Register reg3 = no_reg,
89 Register reg4 = no_reg,
90 Register reg5 = no_reg,
91 Register reg6 = no_reg);
93 bool AreAliased(Register reg1,
94 Register reg2,
95 Register reg3 = no_reg,
96 Register reg4 = no_reg,
97 Register reg5 = no_reg,
98 Register reg6 = no_reg,
99 Register reg7 = no_reg,
100 Register reg8 = no_reg);
106 inline MemOperand ContextOperand(Register context, int index) {
117 inline MemOperand FieldMemOperand(Register object, int offset) {
122 inline MemOperand UntagSmiMemOperand(Register rm, int offset) {
129 inline MemOperand UntagSmiFieldMemOperand(Register rm, int offset) {
157 #define COND_TYPED_ARGS Condition cond, Register r1, const Operand& r2
189 #define COND_ARGS Condition cond = al, Register rs = zero_reg, \
192 void Jump(Register target, COND_ARGS);
196 static int CallSize(Register target, COND_ARGS);
197 void Call(Register target, COND_ARGS);
210 Register rs = zero_reg, const Operand& rt = Operand(zero_reg)) {
216 Register rs,
226 Register reg = no_reg,
235 Register reg,
240 void Swap(Register reg1, Register reg2, Register scratch = no_reg);
244 inline void Move(Register dst, Register src) {
256 inline void Move(Register dst_low, Register dst_high, FPURegister src) {
261 inline void FmoveHigh(Register dst_high, FPURegister src) {
265 inline void FmoveLow(Register dst_low, FPURegister src) {
269 inline void Move(FPURegister dst, Register src_low, Register src_high) {
276 void Movz(Register rd, Register rs, Register rt);
277 void Movn(Register rd, Register rs, Register rt);
278 void Movt(Register rd, Register rs, uint16_t cc = 0);
279 void Movf(Register rd, Register rs, uint16_t cc = 0);
281 void Clz(Register rd, Register rs);
292 void Load(Register dst, const MemOperand& src, Representation r);
293 void Store(Register src, const MemOperand& dst, Representation r);
296 void LoadRoot(Register destination,
298 void LoadRoot(Register destination,
300 Condition cond, Register src1, const Operand& src2);
303 void StoreRoot(Register source,
305 void StoreRoot(Register source,
307 Condition cond, Register src1, const Operand& src2);
312 void IncrementalMarkingRecordWriteHelper(Register object,
313 Register value,
314 Register address);
325 void RememberedSetHelper(Register object, // Used for debug code.
326 Register addr,
327 Register scratch,
331 void CheckPageFlag(Register object,
332 Register scratch,
338 Register scratch,
343 void JumpIfNotInNewSpace(Register object,
344 Register scratch,
351 void JumpIfInNewSpace(Register object,
352 Register scratch,
358 void HasColor(Register object,
359 Register scratch0,
360 Register scratch1,
365 void JumpIfBlack(Register object,
366 Register scratch0,
367 Register scratch1,
375 void EnsureNotWhite(Register object,
376 Register scratch1,
377 Register scratch2,
378 Register scratch3,
383 void JumpIfDataObject(Register value,
384 Register scratch,
393 Register object,
395 Register value,
396 Register scratch,
407 Register context,
409 Register value,
410 Register scratch,
429 Register object,
430 Register map,
431 Register dst,
439 Register object,
440 Register address,
441 Register value,
456 void CheckAccessGlobalProxy(Register holder_reg,
457 Register scratch,
460 void GetNumberHash(Register reg0, Register scratch);
463 Register elements,
464 Register key,
465 Register result,
466 Register reg0,
467 Register reg1,
468 Register reg2);
516 Register result,
517 Register scratch1,
518 Register scratch2,
522 void Allocate(Register object_size,
523 Register result,
524 Register scratch1,
525 Register scratch2,
533 void UndoAllocationInNewSpace(Register object, Register scratch);
536 void AllocateTwoByteString(Register result,
537 Register length,
538 Register scratch1,
539 Register scratch2,
540 Register scratch3,
542 void AllocateOneByteString(Register result, Register length,
543 Register scratch1, Register scratch2,
544 Register scratch3, Label* gc_required);
545 void AllocateTwoByteConsString(Register result,
546 Register length,
547 Register scratch1,
548 Register scratch2,
550 void AllocateOneByteConsString(Register result, Register length,
551 Register scratch1, Register scratch2,
553 void AllocateTwoByteSlicedString(Register result,
554 Register length,
555 Register scratch1,
556 Register scratch2,
558 void AllocateOneByteSlicedString(Register result, Register length,
559 Register scratch1, Register scratch2,
565 void AllocateHeapNumber(Register result,
566 Register scratch1,
567 Register scratch2,
568 Register heap_number_map,
573 void AllocateHeapNumberWithValue(Register result,
575 Register scratch1,
576 Register scratch2,
583 void instr(Register rd, Register rs, const Operand& rt); \
584 void instr(Register rd, Register rs, Register rt) { \
587 void instr(Register rs, Register rt, int32_t j) { \
592 void instr(Register rs, const Operand& rt); \
593 void instr(Register rs, Register rt) { \
596 void instr(Register rs, int32_t j) { \
641 void mov(Register rd, Register rt) { or_(rd, rt, zero_reg); }
643 void Ulw(Register rd, const MemOperand& rs);
644 void Usw(Register rd, const MemOperand& rs);
645 void Uld(Register rd, const MemOperand& rs, Register scratch = at);
646 void Usd(Register rd, const MemOperand& rs, Register scratch = at);
649 void li(Register rd, Operand j, LiFlags mode = OPTIMIZE_SIZE);
650 inline void li(Register rd, int64_t j, LiFlags mode = OPTIMIZE_SIZE) {
653 void li(Register dst, Handle<Object> value, LiFlags mode = OPTIMIZE_SIZE);
664 void push(Register src) {
668 void Push(Register src) { push(src); }
675 void Push(Register src1, Register src2) {
682 void Push(Register src1, Register src2, Register src3) {
690 void Push(Register src1, Register src2, Register src3, Register src4) {
698 void Push(Register src, Condition cond, Register tst1, Register tst2) {
705 void PushRegisterAsTwoSmis(Register src, Register scratch = at);
706 void PopRegisterAsTwoSmis(Register dst, Register scratch = at);
716 void pop(Register dst) {
720 void Pop(Register dst) { pop(dst); }
723 void Pop(Register src1, Register src2) {
731 void Pop(Register src1, Register src2, Register src3) {
748 void StoreToSafepointRegisterSlot(Register src, Register dst);
751 void LoadFromSafepointRegisterSlot(Register dst, Register src);
756 void FlushICache(Register address, unsigned instructions);
759 void Ins(Register rt, Register rs, uint16_t pos, uint16_t size);
760 void Ext(Register rt, Register rs, uint16_t pos, uint16_t size);
767 void Cvt_d_uw(FPURegister fd, Register rs, FPURegister scratch);
779 void Trunc_uw_d(FPURegister fd, Register rs, FPURegister scratch);
816 Register result,
818 Register scratch,
820 Register except_flag,
830 void TryInlineTruncateDoubleToI(Register result,
837 void TruncateDoubleToI(Register result, DoubleRegister double_input);
842 void TruncateHeapNumberToI(Register result, Register object);
848 void TruncateNumberToI(Register object,
849 Register result,
850 Register heap_number_map,
851 Register scratch,
857 void LoadNumber(Register object,
859 Register heap_number_map,
860 Register scratch,
868 void LoadNumberAsInt32Double(Register object,
870 Register heap_number_map,
871 Register scratch1,
872 Register scratch2,
881 void LoadNumberAsInt32(Register object,
882 Register dst,
883 Register heap_number_map,
884 Register scratch1,
885 Register scratch2,
899 Register arg_count,
909 void LoadContext(Register dst, int context_chain_length);
918 Register map_in_out,
919 Register scratch,
922 void LoadGlobalFunction(int index, Register function);
926 void LoadGlobalFunctionInitialMap(Register function,
927 Register map,
928 Register scratch);
940 void InvokeCode(Register code,
948 void InvokeFunction(Register function,
953 void InvokeFunction(Register function,
966 void IsObjectJSObjectType(Register heap_object,
967 Register map,
968 Register scratch,
971 void IsInstanceJSObjectType(Register map,
972 Register scratch,
975 void IsObjectJSStringType(Register object,
976 Register scratch,
979 void IsObjectNameType(Register object,
980 Register scratch,
999 void Throw(Register value);
1003 void ThrowUncatchable(Register value);
1006 void CopyFields(Register dst, Register src, RegList temps, int field_count);
1011 void CopyBytes(Register src,
1012 Register dst,
1013 Register length,
1014 Register scratch);
1019 void InitializeFieldsWithFiller(Register start_offset,
1020 Register end_offset,
1021 Register filler);
1031 void TryGetFunctionPrototype(Register function,
1032 Register result,
1033 Register scratch,
1037 void GetObjectType(Register function,
1038 Register map,
1039 Register type_reg);
1043 void CheckFastElements(Register map,
1044 Register scratch,
1049 void CheckFastObjectElements(Register map,
1050 Register scratch,
1055 void CheckFastSmiElements(Register map,
1056 Register scratch,
1062 void StoreNumberToDoubleElements(Register value_reg,
1063 Register key_reg,
1064 Register elements_reg,
1065 Register scratch1,
1066 Register scratch2,
1067 Register scratch3,
1075 void CompareMapAndBranch(Register obj,
1076 Register scratch,
1084 void CompareMapAndBranch(Register obj_map,
1094 void CheckMap(Register obj,
1095 Register scratch,
1101 void CheckMap(Register obj,
1102 Register scratch,
1110 void DispatchMap(Register obj,
1111 Register scratch,
1120 Condition IsObjectStringType(Register obj,
1121 Register type,
1122 Register result) {
1132 // Register use:
1135 void IndexFromHash(Register hash, Register index);
1138 void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
1139 void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
1145 Register object,
1147 Register scratch1,
1148 Register scratch2,
1149 Register heap_number_map,
1156 void SmiToDoubleFPURegister(Register smi,
1158 Register scratch1);
1165 void AdduAndCheckForOverflow(Register dst,
1166 Register left,
1167 Register right,
1168 Register overflow_dst,
1169 Register scratch = at);
1171 void SubuAndCheckForOverflow(Register dst,
1172 Register left,
1173 Register right,
1174 Register overflow_dst,
1175 Register scratch = at);
1178 Register overflow_check,
1184 Register overflow_check,
1189 void RetOnOverflow(Register overflow_check, BranchDelaySlot bd = PROTECT) {
1193 void RetOnNoOverflow(Register overflow_check, BranchDelaySlot bd = PROTECT) {
1210 #define COND_ARGS Condition cond = al, Register rs = zero_reg, \
1272 Register scratch);
1274 Register scratch);
1286 void CallCFunction(Register function, int num_arguments);
1290 void CallCFunction(Register function,
1308 void CallApiFunctionAndReturn(Register function_address,
1326 void GetBuiltinEntry(Register target, Builtins::JavaScript id);
1329 void GetBuiltinFunction(Register target, Builtins::JavaScript id);
1344 void TruncatingDiv(Register result, Register dividend, int32_t divisor);
1350 Register scratch1, Register scratch2);
1352 Register scratch1, Register scratch2);
1354 Register scratch1, Register scratch2);
1362 void Assert(Condition cc, BailoutReason reason, Register rs, Operand rt);
1363 void AssertFastElements(Register elements);
1366 void Check(Condition cc, BailoutReason reason, Register rs, Operand rt);
1385 void JumpIfNotPowerOfTwoOrZero(Register reg,
1386 Register scratch,
1393 void SmiTagCheckOverflow(Register reg, Register overflow);
1394 void SmiTagCheckOverflow(Register dst, Register src, Register overflow);
1396 void SmiTag(Register dst, Register src) {
1406 void SmiTag(Register reg) {
1413 void TrySmiTag(Register reg, Register scratch, Label* not_a_smi) {
1417 void TrySmiTag(Register dst,
1418 Register src,
1419 Register scratch,
1430 void SmiUntag(Register dst, Register src) {
1439 void SmiUntag(Register reg) {
1444 void SmiScale(Register dst, Register src, int scale) {
1455 void SmiLoadUntag(Register dst, MemOperand src);
1457 void SmiLoadScale(Register dst, MemOperand src, int scale);
1460 void SmiLoadWithScale(Register d_smi,
1461 Register d_scaled,
1466 void SmiLoadUntagWithScale(Register d_int,
1467 Register d_scaled,
1473 inline void SmiTst(Register value, Register scratch) {
1476 inline void NonNegativeSmiTst(Register value, Register scratch) {
1482 void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case);
1486 void UntagAndJumpIfNotSmi(Register dst, Register src, Label* non_smi_case);
1489 void JumpIfSmi(Register value,
1491 Register scratch = at,
1495 void JumpIfNotSmi(Register value,
1497 Register scratch = at,
1501 void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi);
1503 void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi);
1506 void AssertNotSmi(Register object);
1507 void AssertSmi(Register object);
1510 void AssertString(Register object);
1513 void AssertName(Register object);
1517 void AssertUndefinedOrAllocationSite(Register object, Register scratch);
1521 void AssertIsRoot(Register reg, Heap::RootListIndex index);
1526 void JumpIfNotHeapNumber(Register object,
1527 Register heap_number_map,
1528 Register scratch,
1539 void LookupNumberStringCache(Register object,
1540 Register result,
1541 Register scratch1,
1542 Register scratch2,
1543 Register scratch3,
1549 Register first_object_instance_type, Register second_object_instance_type,
1550 Register scratch1, Register scratch2, Label* failure);
1554 void JumpIfInstanceTypeIsNotSequentialOneByte(Register type, Register scratch,
1557 void JumpIfNotUniqueNameInstanceType(Register reg, Label* not_unique_name);
1559 void EmitSeqStringSetCharCheck(Register string,
1560 Register index,
1561 Register value,
1562 Register scratch,
1567 void JumpIfNonSmisNotBothSequentialOneByteStrings(Register first,
1568 Register second,
1569 Register scratch1,
1570 Register scratch2,
1575 void JumpIfNotBothSequentialOneByteStrings(Register first, Register second,
1576 Register scratch1,
1577 Register scratch2,
1580 void ClampUint8(Register output_reg, Register input_reg);
1582 void ClampDoubleToUint8(Register result_reg,
1587 void LoadInstanceDescriptors(Register map, Register descriptors);
1588 void EnumLength(Register dst, Register map);
1589 void NumberOfOwnDescriptors(Register dst, Register map);
1592 void DecodeField(Register dst, Register src) {
1597 void DecodeField(Register reg) {
1602 void DecodeFieldToSmi(Register dst, Register src) {
1611 void DecodeFieldToSmi(Register reg) {
1623 void PatchRelocatedValue(Register li_location,
1624 Register scratch,
1625 Register new_value);
1627 void GetRelocatedValue(Register li_location,
1628 Register value,
1629 Register scratch);
1633 void CheckEnumCache(Register null_value, Label* call_runtime);
1642 Register receiver_reg,
1643 Register scratch_reg,
1648 void JumpIfJSArrayHasAllocationMemento(Register receiver_reg,
1649 Register scratch_reg,
1658 void JumpIfDictionaryInPrototypeChain(Register object, Register scratch0,
1659 Register scratch1, Label* found);
1662 void CallCFunctionHelper(Register function,
1667 void BranchAndLinkShort(int16_t offset, Condition cond, Register rs,
1671 void BranchAndLinkShort(Label* L, Condition cond, Register rs,
1682 Register code_reg,
1692 void InitializeNewString(Register string,
1693 Register length,
1695 Register scratch1,
1696 Register scratch2);
1699 void InNewSpace(Register object,
1700 Register scratch,
1707 inline void GetMarkBits(Register addr_reg,
1708 Register bitmap_reg,
1709 Register mask_reg);
1717 MemOperand SafepointRegisterSlot(Register reg);
1718 MemOperand SafepointRegistersAndDoublesSlot(Register reg);