Lines Matching refs:Register
42 inline MemOperand FieldMemOperand(Register object, int offset) {
48 const Register cp = { 8 }; // JavaScript context pointer
49 const Register kRootRegister = { 10 }; // Roots array pointer.
66 bool AreAliased(Register reg1,
67 Register reg2,
68 Register reg3 = no_reg,
69 Register reg4 = no_reg,
70 Register reg5 = no_reg,
71 Register reg6 = no_reg);
90 void Jump(Register target, Condition cond = al);
93 static int CallSize(Register target, Condition cond = al);
94 void Call(Register target, Condition cond = al);
121 void Swap(Register reg1,
122 Register reg2,
123 Register scratch = no_reg,
127 void And(Register dst, Register src1, const Operand& src2,
129 void Ubfx(Register dst, Register src, int lsb, int width,
131 void Sbfx(Register dst, Register src, int lsb, int width,
136 void Bfi(Register dst,
137 Register src,
138 Register scratch,
142 void Bfc(Register dst, Register src, int lsb, int width, Condition cond = al);
143 void Usat(Register dst, int satpos, const Operand& src,
147 void Push(Register src) { push(src); }
148 void Pop(Register dst) { pop(dst); }
150 // Register move. May do nothing if the registers are identical.
151 void Move(Register dst, Handle<Object> value);
152 void Move(Register dst, Register src, Condition cond = al);
156 void LoadRoot(Register destination,
160 void StoreRoot(Register source,
164 void LoadHeapObject(Register dst, Handle<HeapObject> object);
166 void LoadObject(Register result, Handle<Object> object) {
178 void IncrementalMarkingRecordWriteHelper(Register object,
179 Register value,
180 Register address);
190 void RememberedSetHelper(Register object, // Used for debug code.
191 Register addr,
192 Register scratch,
196 void CheckPageFlag(Register object,
197 Register scratch,
203 Register scratch,
208 void JumpIfNotInNewSpace(Register object,
209 Register scratch,
216 void JumpIfInNewSpace(Register object,
217 Register scratch,
223 void HasColor(Register object,
224 Register scratch0,
225 Register scratch1,
230 void JumpIfBlack(Register object,
231 Register scratch0,
232 Register scratch1,
240 void EnsureNotWhite(Register object,
241 Register scratch1,
242 Register scratch2,
243 Register scratch3,
248 void JumpIfDataObject(Register value,
249 Register scratch,
258 Register object,
260 Register value,
261 Register scratch,
270 Register context,
272 Register value,
273 Register scratch,
292 Register object,
293 Register address,
294 Register value,
305 void Push(Register src1, Register src2, Condition cond = al) {
316 void Push(Register src1, Register src2, Register src3, Condition cond = al) {
334 void Push(Register src1,
335 Register src2,
336 Register src3,
337 Register src4,
367 void Pop(Register src1, Register src2, Condition cond = al) {
378 void Pop(Register src1, Register src2, Register src3, Condition cond = al) {
396 void Pop(Register src1,
397 Register src2,
398 Register src3,
399 Register src4,
436 void StoreToSafepointRegisterSlot(Register src, Register dst);
437 void StoreToSafepointRegistersAndDoublesSlot(Register src, Register dst);
440 void LoadFromSafepointRegisterSlot(Register dst, Register src);
443 void Ldrd(Register dst1,
444 Register dst2,
449 void Strd(Register src1,
450 Register src2,
461 void VFPEnsureFPSCRState(Register scratch);
478 const Register fpscr_flags,
482 const Register fpscr_flags,
487 const Register scratch = no_reg);
489 void VmovHigh(Register dst, DwVfpRegister src);
490 void VmovHigh(DwVfpRegister dst, Register src);
491 void VmovLow(Register dst, DwVfpRegister src);
492 void VmovLow(DwVfpRegister dst, Register src);
497 void ConvertNumberToInt32(Register object,
498 Register dst,
499 Register heap_number_map,
500 Register scratch1,
501 Register scratch2,
502 Register scratch3,
510 void LoadNumber(Register object,
512 Register heap_number_map,
513 Register scratch,
521 void LoadNumberAsInt32Double(Register object,
523 Register heap_number_map,
524 Register scratch,
533 void LoadNumberAsInt32(Register object,
534 Register dst,
535 Register heap_number_map,
536 Register scratch,
549 void LeaveExitFrame(bool save_doubles, Register argument_count);
554 void LoadContext(Register dst, int context_chain_length);
563 Register map_in_out,
564 Register scratch,
568 void LoadInitialArrayMap(Register function_in,
569 Register scratch,
570 Register map_out,
573 void LoadGlobalFunction(int index, Register function);
574 void LoadArrayFunction(Register function);
578 void LoadGlobalFunctionInitialMap(Register function,
579 Register map,
580 Register scratch);
594 void SetCallKind(Register dst, CallKind kind);
597 void InvokeCode(Register code,
613 void InvokeFunction(Register function,
626 void IsObjectJSObjectType(Register heap_object,
627 Register map,
628 Register scratch,
631 void IsInstanceJSObjectType(Register map,
632 Register scratch,
635 void IsObjectJSStringType(Register object,
636 Register scratch,
639 void IsObjectNameType(Register object,
640 Register scratch,
661 void Throw(Register value);
665 void ThrowUncatchable(Register value);
673 void CheckAccessGlobalProxy(Register holder_reg,
674 Register scratch,
677 void GetNumberHash(Register t0, Register scratch);
680 Register elements,
681 Register key,
682 Register result,
683 Register t0,
684 Register t1,
685 Register t2);
734 Register result,
735 Register scratch1,
736 Register scratch2,
740 void Allocate(Register object_size,
741 Register result,
742 Register scratch1,
743 Register scratch2,
751 void UndoAllocationInNewSpace(Register object, Register scratch);
754 void AllocateTwoByteString(Register result,
755 Register length,
756 Register scratch1,
757 Register scratch2,
758 Register scratch3,
760 void AllocateAsciiString(Register result,
761 Register length,
762 Register scratch1,
763 Register scratch2,
764 Register scratch3,
766 void AllocateTwoByteConsString(Register result,
767 Register length,
768 Register scratch1,
769 Register scratch2,
771 void AllocateAsciiConsString(Register result,
772 Register length,
773 Register scratch1,
774 Register scratch2,
776 void AllocateTwoByteSlicedString(Register result,
777 Register length,
778 Register scratch1,
779 Register scratch2,
781 void AllocateAsciiSlicedString(Register result,
782 Register length,
783 Register scratch1,
784 Register scratch2,
790 void AllocateHeapNumber(Register result,
791 Register scratch1,
792 Register scratch2,
793 Register heap_number_map,
796 void AllocateHeapNumberWithValue(Register result,
798 Register scratch1,
799 Register scratch2,
800 Register heap_number_map,
804 void CopyFields(Register dst,
805 Register src,
812 void CopyBytes(Register src,
813 Register dst,
814 Register length,
815 Register scratch);
820 void InitializeFieldsWithFiller(Register start_offset,
821 Register end_offset,
822 Register filler);
832 void TryGetFunctionPrototype(Register function,
833 Register result,
834 Register scratch,
845 void CompareObjectType(Register heap_object,
846 Register map,
847 Register type_reg,
853 void CompareInstanceType(Register map,
854 Register type_reg,
860 void CheckFastElements(Register map,
861 Register scratch,
866 void CheckFastObjectElements(Register map,
867 Register scratch,
872 void CheckFastSmiElements(Register map,
873 Register scratch,
879 void StoreNumberToDoubleElements(Register value_reg,
880 Register key_reg,
881 Register elements_reg,
882 Register scratch1,
891 void CompareMap(Register obj,
892 Register scratch,
898 void CompareMap(Register obj_map,
906 void CheckMap(Register obj,
907 Register scratch,
913 void CheckMap(Register obj,
914 Register scratch,
923 void DispatchMap(Register obj,
924 Register scratch,
932 void CompareRoot(Register obj, Heap::RootListIndex index);
940 Condition IsObjectStringType(Register obj,
941 Register type,
956 // Register use:
959 void IndexFromHash(Register hash, Register index);
962 void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
963 void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
967 void SmiToDouble(LowDwVfpRegister value, Register smi);
976 void TryDoubleToInt32Exact(Register result,
984 void TryInt32Floor(Register result,
986 Register input_high,
995 void ECMAToInt32(Register result,
997 Register scratch,
998 Register scratch_high,
999 Register scratch_low,
1004 void CheckFor32DRegs(Register scratch);
1008 void SaveFPRegs(Register location, Register scratch);
1012 void RestoreFPRegs(Register location, Register scratch);
1063 Register scratch);
1065 Register scratch);
1073 void SetCallCDoubleArguments(DwVfpRegister dreg, Register reg);
1081 void CallCFunction(Register function, int num_arguments);
1085 void CallCFunction(Register function,
1098 Register thunk_last_arg,
1114 void GetBuiltinEntry(Register target, Builtins::JavaScript id);
1117 void GetBuiltinFunction(Register target, Builtins::JavaScript id);
1129 Register scratch1, Register scratch2);
1131 Register scratch1, Register scratch2);
1133 Register scratch1, Register scratch2);
1142 void AssertFastElements(Register elements);
1177 void JumpIfNotPowerOfTwoOrZero(Register reg,
1178 Register scratch,
1186 void JumpIfNotPowerOfTwoOrZeroAndNeg(Register reg,
1187 Register scratch,
1194 void SmiTag(Register reg, SBit s = LeaveCC) {
1197 void SmiTag(Register dst, Register src, SBit s = LeaveCC) {
1204 void TrySmiTag(Register reg, Label* not_a_smi) {
1207 void TrySmiTag(Register reg, Register src, Label* not_a_smi) {
1214 void SmiUntag(Register reg, SBit s = LeaveCC) {
1217 void SmiUntag(Register dst, Register src, SBit s = LeaveCC) {
1223 void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case);
1227 void UntagAndJumpIfNotSmi(Register dst, Register src, Label* non_smi_case);
1230 inline void SmiTst(Register value) {
1233 inline void NonNegativeSmiTst(Register value) {
1237 inline void JumpIfSmi(Register value, Label* smi_label) {
1242 inline void JumpIfNotSmi(Register value, Label* not_smi_label) {
1247 void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi);
1249 void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi);
1252 void AssertNotSmi(Register object);
1253 void AssertSmi(Register object);
1256 void AssertString(Register object);
1259 void AssertName(Register object);
1263 void AssertIsRoot(Register reg, Heap::RootListIndex index);
1268 void JumpIfNotHeapNumber(Register object,
1269 Register heap_number_map,
1270 Register scratch,
1278 void JumpIfNonSmisNotBothSequentialAsciiStrings(Register object1,
1279 Register object2,
1280 Register scratch1,
1281 Register scratch2,
1286 void JumpIfNotBothSequentialAsciiStrings(Register first,
1287 Register second,
1288 Register scratch1,
1289 Register scratch2,
1295 Register first_object_instance_type,
1296 Register second_object_instance_type,
1297 Register scratch1,
1298 Register scratch2,
1303 void JumpIfInstanceTypeIsNotSequentialAscii(Register type,
1304 Register scratch,
1307 void JumpIfNotUniqueName(Register reg, Label* not_unique_name);
1314 void GetRelocatedValueLocation(Register ldr_location,
1315 Register result);
1318 void ClampUint8(Register output_reg, Register input_reg);
1320 void ClampDoubleToUint8(Register result_reg,
1325 void LoadInstanceDescriptors(Register map, Register descriptors);
1326 void EnumLength(Register dst, Register map);
1327 void NumberOfOwnDescriptors(Register dst, Register map);
1330 void DecodeField(Register reg) {
1343 void CheckEnumCache(Register null_value, Label* call_runtime);
1351 void TestJSArrayForAllocationMemento(Register receiver_reg,
1352 Register scratch_reg);
1355 void CallCFunctionHelper(Register function,
1365 Register code_reg,
1372 void InitializeNewString(Register string,
1373 Register length,
1375 Register scratch1,
1376 Register scratch2);
1379 void InNewSpace(Register object,
1380 Register scratch,
1387 inline void GetMarkBits(Register addr_reg,
1388 Register bitmap_reg,
1389 Register mask_reg);
1397 MemOperand SafepointRegisterSlot(Register reg);
1398 MemOperand SafepointRegistersAndDoublesSlot(Register reg);
1445 inline MemOperand ContextOperand(Register context, int index) {