Lines Matching refs:Register
17 const Register kReturnRegister0 = {Register::kCode_r0};
18 const Register kReturnRegister1 = {Register::kCode_r1};
19 const Register kReturnRegister2 = {Register::kCode_r2};
20 const Register kJSFunctionRegister = {Register::kCode_r1};
21 const Register kContextRegister = {Register::kCode_r7};
22 const Register kAllocateSizeRegister = {Register::kCode_r1};
23 const Register kInterpreterAccumulatorRegister = {Register::kCode_r0};
24 const Register kInterpreterBytecodeOffsetRegister = {Register::kCode_r5};
25 const Register kInterpreterBytecodeArrayRegister = {Register::kCode_r6};
26 const Register kInterpreterDispatchTableRegister = {Register::kCode_r8};
27 const Register kJavaScriptCallArgCountRegister = {Register::kCode_r0};
28 const Register kJavaScriptCallNewTargetRegister = {Register::kCode_r3};
29 const Register kRuntimeCallFunctionRegister = {Register::kCode_r1};
30 const Register kRuntimeCallArgCountRegister = {Register::kCode_r0};
36 inline MemOperand FieldMemOperand(Register object, int offset) {
42 const Register cp = {Register::kCode_r7}; // JavaScript context pointer.
43 const Register pp = {Register::kCode_r8}; // Constant pool pointer.
44 const Register kRootRegister = {Register::kCode_r10}; // Roots array pointer.
64 Register GetRegisterThatIsNotOneOf(Register reg1,
65 Register reg2 = no_reg,
66 Register reg3 = no_reg,
67 Register reg4 = no_reg,
68 Register reg5 = no_reg,
69 Register reg6 = no_reg);
73 bool AreAliased(Register reg1,
74 Register reg2,
75 Register reg3 = no_reg,
76 Register reg4 = no_reg,
77 Register reg5 = no_reg,
78 Register reg6 = no_reg,
79 Register reg7 = no_reg,
80 Register reg8 = no_reg);
99 static int CallSize(Register target, Condition cond = al);
106 void Jump(Register target, Condition cond = al);
109 void Call(Register target, Condition cond = al);
132 Register reg, typename Descriptor::ParameterIndices parameter_index,
141 void Drop(Register count, Condition cond = al);
147 void Swap(Register reg1,
148 Register reg2,
149 Register scratch = no_reg,
152 void Mls(Register dst, Register src1, Register src2, Register srcA,
154 void And(Register dst, Register src1, const Operand& src2,
156 void Ubfx(Register dst, Register src, int lsb, int width,
158 void Sbfx(Register dst, Register src, int lsb, int width,
163 void Bfi(Register dst,
164 Register src,
165 Register scratch,
169 void Bfc(Register dst, Register src, int lsb, int width, Condition cond = al);
172 void Push(Register src) { push(src); }
173 void Pop(Register dst) { pop(dst); }
175 // Register move. May do nothing if the registers are identical.
176 void Move(Register dst, Smi* smi) { mov(dst, Operand(smi)); }
177 void Move(Register dst, Handle<Object> value);
178 void Move(Register dst, Register src, Condition cond = al);
179 void Move(Register dst, const Operand& src, SBit sbit = LeaveCC,
188 // Register swap.
192 void Load(Register dst, const MemOperand& src, Representation r);
193 void Store(Register src, const MemOperand& dst, Representation r);
196 void LoadRoot(Register destination,
200 void StoreRoot(Register source,
207 void IncrementalMarkingRecordWriteHelper(Register object,
208 Register value,
209 Register address);
219 void RememberedSetHelper(Register object, // Used for debug code.
220 Register addr,
221 Register scratch,
225 void CheckPageFlag(Register object,
226 Register scratch,
233 void JumpIfNotInNewSpace(Register object,
234 Register scratch,
241 void JumpIfInNewSpace(Register object,
242 Register scratch,
248 void HasColor(Register object,
249 Register scratch0,
250 Register scratch1,
255 void JumpIfBlack(Register object,
256 Register scratch0,
257 Register scratch1,
262 void JumpIfWhite(Register value, Register scratch1, Register scratch2,
263 Register scratch3, Label* value_is_white);
271 Register object,
273 Register value,
274 Register scratch,
285 Register context,
287 Register value,
288 Register scratch,
308 void RecordWriteCodeEntryField(Register js_function, Register code_entry,
309 Register scratch);
312 Register object,
313 Register map,
314 Register dst,
322 Register object,
323 Register address,
324 Register value,
337 void Push(Register src1, Register src2, Condition cond = al) {
347 void Push(Register src1, Register src2, Register src3, Condition cond = al) {
362 void Push(Register src1,
363 Register src2,
364 Register src3,
365 Register src4,
389 void Push(Register src1, Register src2, Register src3, Register src4,
390 Register src5, Condition cond = al) {
418 void Pop(Register src1, Register src2, Condition cond = al) {
429 void Pop(Register src1, Register src2, Register src3, Condition cond = al) {
445 void Pop(Register src1,
446 Register src2,
447 Register src3,
448 Register src4,
474 void PushCommonFrame(Register marker_reg = no_reg);
478 void PushStandardFrame(Register function_reg);
480 void PopCommonFrame(Register marker_reg = no_reg);
488 void StoreToSafepointRegisterSlot(Register src, Register dst);
491 void LoadFromSafepointRegisterSlot(Register dst, Register src);
494 void Ldrd(Register dst1,
495 Register dst2,
500 void Strd(Register src1,
501 Register src2,
531 const Register fpscr_flags,
534 const Register fpscr_flags,
540 const Register fpscr_flags,
544 const Register fpscr_flags,
549 const Register scratch = no_reg);
551 void VmovHigh(Register dst, DwVfpRegister src);
552 void VmovHigh(DwVfpRegister dst, Register src);
553 void VmovLow(Register dst, DwVfpRegister src);
554 void VmovLow(DwVfpRegister dst, Register src);
557 void VmovExtended(Register dst, int src_code);
558 void VmovExtended(int dst_code, Register src);
560 void VmovExtended(int dst_code, int src_code, Register scratch);
561 void VmovExtended(int dst_code, const MemOperand& src, Register scratch);
562 void VmovExtended(const MemOperand& dst, int src_code, Register scratch);
564 void ExtractLane(Register dst, QwNeonRegister src, NeonDataType dt, int lane);
565 void ExtractLane(SwVfpRegister dst, QwNeonRegister src, Register scratch,
567 void ReplaceLane(QwNeonRegister dst, QwNeonRegister src, Register src_lane,
570 SwVfpRegister src_lane, Register scratch, int lane);
571 void Swizzle(QwNeonRegister dst, QwNeonRegister src, Register scratch,
574 void LslPair(Register dst_low, Register dst_high, Register src_low,
575 Register src_high, Register scratch, Register shift);
576 void LslPair(Register dst_low, Register dst_high, Register src_low,
577 Register src_high, uint32_t shift);
578 void LsrPair(Register dst_low, Register dst_high, Register src_low,
579 Register src_high, Register scratch, Register shift);
580 void LsrPair(Register dst_low, Register dst_high, Register src_low,
581 Register src_high, uint32_t shift);
582 void AsrPair(Register dst_low, Register dst_high, Register src_low,
583 Register src_high, Register scratch, Register shift);
584 void AsrPair(Register dst_low, Register dst_high, Register src_low,
585 Register src_high, uint32_t shift);
590 void LoadNumber(Register object,
592 Register heap_number_map,
593 Register scratch,
601 void LoadNumberAsInt32Double(Register object,
603 Register heap_number_map,
604 Register scratch,
613 void LoadNumberAsInt32(Register object,
614 Register dst,
615 Register heap_number_map,
616 Register scratch,
633 void LeaveExitFrame(bool save_doubles, Register argument_count,
640 void LoadContext(Register dst, int context_chain_length);
643 void LoadGlobalObject(Register dst) {
648 void LoadGlobalProxy(Register dst) {
652 void LoadNativeContextSlot(int index, Register dst);
656 void LoadGlobalFunctionInitialMap(Register function,
657 Register map,
658 Register scratch);
675 Register caller_args_count_reg, Register scratch0,
676 Register scratch1);
679 void InvokeFunctionCode(Register function, Register new_target,
685 void CheckDebugHook(Register fun, Register new_target,
691 void InvokeFunction(Register function,
692 Register new_target,
697 void InvokeFunction(Register function,
709 void IsObjectJSStringType(Register object,
710 Register scratch,
713 void IsObjectNameType(Register object,
714 Register scratch,
732 void GetNumberHash(Register t0, Register scratch);
780 Register result,
781 Register scratch1,
782 Register scratch2,
786 void Allocate(Register object_size, Register result, Register result_end,
787 Register scratch, Label* gc_required, AllocationFlags flags);
792 void FastAllocate(int object_size, Register result, Register scratch1,
793 Register scratch2, AllocationFlags flags);
795 void FastAllocate(Register object_size, Register result, Register result_end,
796 Register scratch, AllocationFlags flags);
801 void AllocateHeapNumber(Register result,
802 Register scratch1,
803 Register scratch2,
804 Register heap_number_map,
807 void AllocateHeapNumberWithValue(Register result,
809 Register scratch1,
810 Register scratch2,
811 Register heap_number_map,
816 void AllocateJSValue(Register result, Register constructor, Register value,
817 Register scratch1, Register scratch2,
823 void InitializeFieldsWithFiller(Register current_address,
824 Register end_address, Register filler);
831 void GetMapConstructor(Register result, Register map, Register temp,
832 Register temp2);
842 void CompareObjectType(Register heap_object,
843 Register map,
844 Register type_reg,
850 void CompareInstanceType(Register map,
851 Register type_reg,
858 void CompareMap(Register obj,
859 Register scratch,
865 void CompareMap(Register obj_map,
873 void CheckMap(Register obj,
874 Register scratch,
880 void CheckMap(Register obj,
881 Register scratch,
890 void DispatchWeakMap(Register obj, Register scratch1, Register scratch2,
895 void CmpWeakValue(Register value, Handle<WeakCell> cell, Register scratch);
897 void GetWeakValue(Register value, Handle<WeakCell> cell);
901 void LoadWeakValue(Register value, Handle<WeakCell> cell, Label* miss);
905 void CompareRoot(Register obj, Heap::RootListIndex index);
912 void JumpIfRoot(Register with, Heap::RootListIndex index, Label* if_equal) {
918 void JumpIfNotRoot(Register with, Heap::RootListIndex index,
929 Condition IsObjectStringType(Register obj,
930 Register type,
941 void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
942 void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
946 void SmiToDouble(LowDwVfpRegister value, Register smi);
955 void TryDoubleToInt32Exact(Register result,
963 void TryInt32Floor(Register result,
965 Register input_high,
976 void TryInlineTruncateDoubleToI(Register result,
983 void TruncateDoubleToI(Register result, DwVfpRegister double_input);
988 void TruncateHeapNumberToI(Register result, Register object);
994 void TruncateNumberToI(Register object,
995 Register result,
996 Register heap_number_map,
997 Register scratch1,
1002 void CheckFor32DRegs(Register scratch);
1006 void SaveFPRegs(Register location, Register scratch);
1010 void RestoreFPRegs(Register location, Register scratch);
1093 Register scratch);
1095 Register scratch);
1111 void CallCFunction(Register function, int num_arguments);
1115 void CallCFunction(Register function,
1134 void TruncatingDiv(Register result, Register dividend, int32_t divisor);
1140 Register scratch1, Register scratch2);
1142 Register scratch1, Register scratch2);
1144 Register scratch1, Register scratch2);
1153 void AssertFastElements(Register elements);
1186 void JumpIfNotPowerOfTwoOrZero(Register reg,
1187 Register scratch,
1195 void JumpIfNotPowerOfTwoOrZeroAndNeg(Register reg,
1196 Register scratch,
1203 void SmiTag(Register reg, SBit s = LeaveCC) {
1206 void SmiTag(Register dst, Register src, SBit s = LeaveCC) {
1213 void TrySmiTag(Register reg, Label* not_a_smi) {
1216 void TrySmiTag(Register reg, Register src, Label* not_a_smi) {
1223 void SmiUntag(Register reg, SBit s = LeaveCC) {
1226 void SmiUntag(Register dst, Register src, SBit s = LeaveCC) {
1232 void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case);
1235 inline void SmiTst(Register value) {
1238 inline void NonNegativeSmiTst(Register value) {
1242 inline void JumpIfSmi(Register value, Label* smi_label) {
1247 inline void JumpIfNotSmi(Register value, Label* not_smi_label) {
1252 void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi);
1254 void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi);
1257 void AssertNotNumber(Register object);
1260 void AssertNotSmi(Register object);
1261 void AssertSmi(Register object);
1264 void AssertString(Register object);
1267 void AssertName(Register object);
1270 void AssertFunction(Register object);
1274 void AssertBoundFunction(Register object);
1278 void AssertGeneratorObject(Register object);
1281 void AssertReceiver(Register object);
1285 void AssertUndefinedOrAllocationSite(Register object, Register scratch);
1289 void AssertIsRoot(Register reg, Heap::RootListIndex index);
1294 void JumpIfNotHeapNumber(Register object,
1295 Register heap_number_map,
1296 Register scratch,
1304 void JumpIfNonSmisNotBothSequentialOneByteStrings(Register object1,
1305 Register object2,
1306 Register scratch1,
1307 Register scratch2,
1312 void JumpIfNotBothSequentialOneByteStrings(Register first, Register second,
1313 Register scratch1,
1314 Register scratch2,
1320 Register first_object_instance_type, Register second_object_instance_type,
1321 Register scratch1, Register scratch2, Label* failure);
1323 void JumpIfNotUniqueNameInstanceType(Register reg, Label* not_unique_name);
1325 void EmitSeqStringSetCharCheck(Register string,
1326 Register index,
1327 Register value,
1331 void ClampUint8(Register output_reg, Register input_reg);
1333 void ClampDoubleToUint8(Register result_reg,
1338 void LoadInstanceDescriptors(Register map, Register descriptors);
1339 void EnumLength(Register dst, Register map);
1340 void NumberOfOwnDescriptors(Register dst, Register map);
1341 void LoadAccessor(Register dst, Register holder, int accessor_index,
1345 void DecodeField(Register dst, Register src) {
1350 void DecodeField(Register reg) {
1355 void DecodeFieldToSmi(Register dst, Register src) {
1372 void DecodeFieldToSmi(Register reg) {
1377 void EmitLoadFeedbackVector(Register vector);
1385 void EnterBuiltinFrame(Register context, Register target, Register argc);
1386 void LeaveBuiltinFrame(Register context, Register target, Register argc);
1398 void TestJSArrayForAllocationMemento(Register receiver_reg,
1399 Register scratch_reg,
1404 Register code_target_address);
1408 void CallCFunctionHelper(Register function,
1423 void InNewSpace(Register object,
1424 Register scratch,
1431 inline void GetMarkBits(Register addr_reg,
1432 Register bitmap_reg,
1433 Register mask_reg);
1437 MemOperand SafepointRegisterSlot(Register reg);
1438 MemOperand SafepointRegistersAndDoublesSlot(Register reg);
1501 inline MemOperand ContextMemOperand(Register context, int index = 0) {