Lines Matching refs:Register
41 // Reserved Register Usage Summary.
99 bool AreAliased(Register r1, Register r2, Register r3, Register r4);
105 inline MemOperand ContextOperand(Register context, int index) {
116 inline MemOperand FieldMemOperand(Register object, int offset) {
141 #define COND_TYPED_ARGS Condition cond, Register r1, const Operand& r2
172 #define COND_ARGS Condition cond = al, Register rs = zero_reg, \
175 void Jump(Register target, COND_ARGS);
179 static int CallSize(Register target, COND_ARGS);
180 void Call(Register target, COND_ARGS);
193 Register rs = zero_reg, const Operand& rt = Operand(zero_reg)) {
199 Register rs,
209 Register reg = no_reg,
218 Register reg,
223 void Swap(Register reg1, Register reg2, Register scratch = no_reg);
227 inline void Move(Register dst, Register src) {
239 inline void Move(Register dst_low, Register dst_high, FPURegister src) {
244 inline void Move(FPURegister dst, Register src_low, Register src_high) {
251 void Movz(Register rd, Register rs, Register rt);
252 void Movn(Register rd, Register rs, Register rt);
253 void Movt(Register rd, Register rs, uint16_t cc = 0);
254 void Movf(Register rd, Register rs, uint16_t cc = 0);
256 void Clz(Register rd, Register rs);
268 void LoadRoot(Register destination,
270 void LoadRoot(Register destination,
272 Condition cond, Register src1, const Operand& src2);
275 void StoreRoot(Register source,
277 void StoreRoot(Register source,
279 Condition cond, Register src1, const Operand& src2);
281 void LoadHeapObject(Register dst, Handle<HeapObject> object);
283 void LoadObject(Register result, Handle<Object> object) {
294 void IncrementalMarkingRecordWriteHelper(Register object,
295 Register value,
296 Register address);
307 void RememberedSetHelper(Register object, // Used for debug code.
308 Register addr,
309 Register scratch,
313 void CheckPageFlag(Register object,
314 Register scratch,
321 void JumpIfNotInNewSpace(Register object,
322 Register scratch,
329 void JumpIfInNewSpace(Register object,
330 Register scratch,
336 void HasColor(Register object,
337 Register scratch0,
338 Register scratch1,
343 void JumpIfBlack(Register object,
344 Register scratch0,
345 Register scratch1,
353 void EnsureNotWhite(Register object,
354 Register scratch1,
355 Register scratch2,
356 Register scratch3,
361 void JumpIfDataObject(Register value,
362 Register scratch,
371 Register object,
373 Register value,
374 Register scratch,
383 Register context,
385 Register value,
386 Register scratch,
405 Register object,
406 Register address,
407 Register value,
420 void CheckAccessGlobalProxy(Register holder_reg,
421 Register scratch,
424 void GetNumberHash(Register reg0, Register scratch);
427 Register elements,
428 Register key,
429 Register result,
430 Register reg0,
431 Register reg1,
432 Register reg2);
480 Register result,
481 Register scratch1,
482 Register scratch2,
485 void AllocateInNewSpace(Register object_size,
486 Register result,
487 Register scratch1,
488 Register scratch2,
496 void UndoAllocationInNewSpace(Register object, Register scratch);
499 void AllocateTwoByteString(Register result,
500 Register length,
501 Register scratch1,
502 Register scratch2,
503 Register scratch3,
505 void AllocateAsciiString(Register result,
506 Register length,
507 Register scratch1,
508 Register scratch2,
509 Register scratch3,
511 void AllocateTwoByteConsString(Register result,
512 Register length,
513 Register scratch1,
514 Register scratch2,
516 void AllocateAsciiConsString(Register result,
517 Register length,
518 Register scratch1,
519 Register scratch2,
521 void AllocateTwoByteSlicedString(Register result,
522 Register length,
523 Register scratch1,
524 Register scratch2,
526 void AllocateAsciiSlicedString(Register result,
527 Register length,
528 Register scratch1,
529 Register scratch2,
535 void AllocateHeapNumber(Register result,
536 Register scratch1,
537 Register scratch2,
538 Register heap_number_map,
540 void AllocateHeapNumberWithValue(Register result,
542 Register scratch1,
543 Register scratch2,
550 void instr(Register rd, Register rs, const Operand& rt); \
551 void instr(Register rd, Register rs, Register rt) { \
554 void instr(Register rs, Register rt, int32_t j) { \
559 void instr(Register rs, const Operand& rt); \
560 void instr(Register rs, Register rt) { \
563 void instr(Register rs, int32_t j) { \
594 void mov(Register rd, Register rt) { or_(rd, rt, zero_reg); }
597 void li(Register rd, Operand j, LiFlags mode = OPTIMIZE_SIZE);
598 inline void li(Register rd, int32_t j, LiFlags mode = OPTIMIZE_SIZE) {
601 inline void li(Register dst, Handle<Object> value,
616 void push(Register src) {
625 void Push(Register src1, Register src2) {
632 void Push(Register src1, Register src2, Register src3) {
640 void Push(Register src1, Register src2, Register src3, Register src4) {
648 void Push(Register src, Condition cond, Register tst1, Register tst2) {
664 void pop(Register dst) {
670 void Pop(Register src1, Register src2) {
678 void Pop(Register src1, Register src2, Register src3) {
697 void StoreToSafepointRegisterSlot(Register src, Register dst);
698 void StoreToSafepointRegistersAndDoublesSlot(Register src, Register dst);
701 void LoadFromSafepointRegisterSlot(Register dst, Register src);
705 void FlushICache(Register address, unsigned instructions);
708 void Ins(Register rt, Register rs, uint16_t pos, uint16_t size);
709 void Ext(Register rt, Register rs, uint16_t pos, uint16_t size);
716 void Cvt_d_uw(FPURegister fd, Register rs, FPURegister scratch);
720 void Trunc_uw_d(FPURegister fd, Register rs, FPURegister scratch);
748 void ConvertToInt32(Register source,
749 Register dest,
750 Register scratch,
751 Register scratch2,
762 Register scratch1,
763 Register except_flag,
773 void EmitOutOfInt32RangeTruncate(Register result,
774 Register input_high,
775 Register input_low,
776 Register scratch);
781 void EmitECMATruncate(Register result,
784 Register scratch,
785 Register scratch2,
786 Register scratch3);
797 Register arg_count,
806 void LoadContext(Register dst, int context_chain_length);
815 Register map_in_out,
816 Register scratch,
820 void LoadInitialArrayMap(Register function_in,
821 Register scratch,
822 Register map_out);
824 void LoadGlobalFunction(int index, Register function);
828 void LoadGlobalFunctionInitialMap(Register function,
829 Register map,
830 Register scratch);
844 void SetCallKind(Register dst, CallKind kind);
847 void InvokeCode(Register code,
863 void InvokeFunction(Register function,
876 void IsObjectJSObjectType(Register heap_object,
877 Register map,
878 Register scratch,
881 void IsInstanceJSObjectType(Register map,
882 Register scratch,
885 void IsObjectJSStringType(Register object,
886 Register scratch,
908 void Throw(Register value);
912 void ThrowUncatchable(Register value);
915 void CopyFields(Register dst, Register src, RegList temps, int field_count);
920 void CopyBytes(Register src,
921 Register dst,
922 Register length,
923 Register scratch);
928 void InitializeFieldsWithFiller(Register start_offset,
929 Register end_offset,
930 Register filler);
940 void TryGetFunctionPrototype(Register function,
941 Register result,
942 Register scratch,
946 void GetObjectType(Register function,
947 Register map,
948 Register type_reg);
952 void CheckFastElements(Register map,
953 Register scratch,
958 void CheckFastObjectElements(Register map,
959 Register scratch,
964 void CheckFastSmiOnlyElements(Register map,
965 Register scratch,
972 void StoreNumberToDoubleElements(Register value_reg,
973 Register key_reg,
974 Register receiver_reg,
975 Register elements_reg,
976 Register scratch1,
977 Register scratch2,
978 Register scratch3,
979 Register scratch4,
986 void CompareMapAndBranch(Register obj,
987 Register scratch,
998 void CheckMap(Register obj,
999 Register scratch,
1006 void CheckMap(Register obj,
1007 Register scratch,
1015 void DispatchMap(Register obj,
1016 Register scratch,
1029 Condition IsObjectStringType(Register obj,
1030 Register type,
1031 Register result) {
1041 // Register use:
1044 void IndexFromHash(Register hash, Register index);
1047 void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
1048 void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
1054 Register object,
1056 Register scratch1,
1057 Register scratch2,
1058 Register heap_number_map,
1065 void SmiToDoubleFPURegister(Register smi,
1067 Register scratch1);
1074 void AdduAndCheckForOverflow(Register dst,
1075 Register left,
1076 Register right,
1077 Register overflow_dst,
1078 Register scratch = at);
1080 void SubuAndCheckForOverflow(Register dst,
1081 Register left,
1082 Register right,
1083 Register overflow_dst,
1084 Register scratch = at);
1087 Register overflow_check,
1093 Register overflow_check,
1098 void RetOnOverflow(Register overflow_check, BranchDelaySlot bd = PROTECT) {
1102 void RetOnNoOverflow(Register overflow_check, BranchDelaySlot bd = PROTECT) {
1122 Register r1 = zero_reg,
1169 Register scratch);
1171 Register scratch);
1183 void CallCFunction(Register function, int num_arguments);
1187 void CallCFunction(Register function,
1198 void SetCallCDoubleArguments(DoubleRegister dreg, Register reg);
1218 void GetBuiltinEntry(Register target, Builtins::JavaScript id);
1221 void GetBuiltinFunction(Register target, Builtins::JavaScript id);
1238 Register scratch1, Register scratch2);
1240 Register scratch1, Register scratch2);
1242 Register scratch1, Register scratch2);
1250 void Assert(Condition cc, const char* msg, Register rs, Operand rt);
1251 void AssertRegisterIsRoot(Register reg, Heap::RootListIndex index);
1252 void AssertFastElements(Register elements);
1255 void Check(Condition cc, const char* msg, Register rs, Operand rt);
1276 void JumpIfNotPowerOfTwoOrZero(Register reg,
1277 Register scratch,
1283 void SmiTag(Register reg) {
1288 void SmiTagCheckOverflow(Register reg, Register overflow);
1289 void SmiTagCheckOverflow(Register dst, Register src, Register overflow);
1291 void SmiTag(Register dst, Register src) {
1295 void SmiUntag(Register reg) {
1299 void SmiUntag(Register dst, Register src) {
1305 void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case);
1309 void UntagAndJumpIfNotSmi(Register dst, Register src, Label* non_smi_case);
1312 void JumpIfSmi(Register value,
1314 Register scratch = at,
1318 void JumpIfNotSmi(Register value,
1320 Register scratch = at,
1324 void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi);
1326 void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi);
1329 void AbortIfSmi(Register object);
1330 void AbortIfNotSmi(Register object);
1333 void AbortIfNotString(Register object);
1336 void AbortIfNotRootValue(Register src,
1343 void JumpIfNotHeapNumber(Register object,
1344 Register heap_number_map,
1345 Register scratch,
1354 Register first_object_instance_type,
1355 Register second_object_instance_type,
1356 Register scratch1,
1357 Register scratch2,
1362 void JumpIfInstanceTypeIsNotSequentialAscii(Register type,
1363 Register scratch,
1368 void JumpIfNonSmisNotBothSequentialAsciiStrings(Register first,
1369 Register second,
1370 Register scratch1,
1371 Register scratch2,
1376 void JumpIfNotBothSequentialAsciiStrings(Register first,
1377 Register second,
1378 Register scratch1,
1379 Register scratch2,
1382 void ClampUint8(Register output_reg, Register input_reg);
1384 void ClampDoubleToUint8(Register result_reg,
1389 void LoadInstanceDescriptors(Register map, Register descriptors);
1397 void PatchRelocatedValue(Register li_location,
1398 Register scratch,
1399 Register new_value);
1401 void GetRelocatedValue(Register li_location,
1402 Register value,
1403 Register scratch);
1407 void CheckEnumCache(Register null_value, Label* call_runtime);
1410 void CallCFunctionHelper(Register function,
1415 void BranchShort(int16_t offset, Condition cond, Register rs,
1419 void BranchShort(Label* L, Condition cond, Register rs,
1423 void BranchAndLinkShort(int16_t offset, Condition cond, Register rs,
1427 void BranchAndLinkShort(Label* L, Condition cond, Register rs,
1438 Register code_reg,
1449 void InitializeNewString(Register string,
1450 Register length,
1452 Register scratch1,
1453 Register scratch2);
1456 void InNewSpace(Register object,
1457 Register scratch,
1464 inline void GetMarkBits(Register addr_reg,
1465 Register bitmap_reg,
1466 Register mask_reg);
1474 MemOperand SafepointRegisterSlot(Register reg);
1475 MemOperand SafepointRegistersAndDoublesSlot(Register reg);