Lines Matching refs:Register
18 // Reserved Register Usage Summary.
80 Register GetRegisterThatIsNotOneOf(Register reg1,
81 Register reg2 = no_reg,
82 Register reg3 = no_reg,
83 Register reg4 = no_reg,
84 Register reg5 = no_reg,
85 Register reg6 = no_reg);
87 bool AreAliased(Register reg1,
88 Register reg2,
89 Register reg3 = no_reg,
90 Register reg4 = no_reg,
91 Register reg5 = no_reg,
92 Register reg6 = no_reg,
93 Register reg7 = no_reg,
94 Register reg8 = no_reg);
100 inline MemOperand ContextOperand(Register context, int index) {
111 inline MemOperand FieldMemOperand(Register object, int offset) {
136 #define COND_TYPED_ARGS Condition cond, Register r1, const Operand& r2
168 #define COND_ARGS Condition cond = al, Register rs = zero_reg, \
171 void Jump(Register target, COND_ARGS);
175 static int CallSize(Register target, COND_ARGS);
176 void Call(Register target, COND_ARGS);
189 Register rs = zero_reg, const Operand& rt = Operand(zero_reg)) {
195 Register rs,
205 Register reg = no_reg,
214 Register reg,
219 void Swap(Register reg1, Register reg2, Register scratch = no_reg);
223 inline void Move(Register dst, Register src) {
235 inline void Move(Register dst_low, Register dst_high, FPURegister src) {
240 inline void FmoveHigh(Register dst_high, FPURegister src) {
244 inline void FmoveLow(Register dst_low, FPURegister src) {
248 inline void Move(FPURegister dst, Register src_low, Register src_high) {
255 void Movz(Register rd, Register rs, Register rt);
256 void Movn(Register rd, Register rs, Register rt);
257 void Movt(Register rd, Register rs, uint16_t cc = 0);
258 void Movf(Register rd, Register rs, uint16_t cc = 0);
260 void Clz(Register rd, Register rs);
271 void Load(Register dst, const MemOperand& src, Representation r);
272 void Store(Register src, const MemOperand& dst, Representation r);
275 void LoadRoot(Register destination,
277 void LoadRoot(Register destination,
279 Condition cond, Register src1, const Operand& src2);
282 void StoreRoot(Register source,
284 void StoreRoot(Register source,
286 Condition cond, Register src1, const Operand& src2);
291 void IncrementalMarkingRecordWriteHelper(Register object,
292 Register value,
293 Register address);
304 void RememberedSetHelper(Register object, // Used for debug code.
305 Register addr,
306 Register scratch,
310 void CheckPageFlag(Register object,
311 Register scratch,
317 Register scratch,
322 void JumpIfNotInNewSpace(Register object,
323 Register scratch,
330 void JumpIfInNewSpace(Register object,
331 Register scratch,
337 void HasColor(Register object,
338 Register scratch0,
339 Register scratch1,
344 void JumpIfBlack(Register object,
345 Register scratch0,
346 Register scratch1,
354 void EnsureNotWhite(Register object,
355 Register scratch1,
356 Register scratch2,
357 Register scratch3,
362 void JumpIfDataObject(Register value,
363 Register scratch,
372 Register object,
374 Register value,
375 Register scratch,
386 Register context,
388 Register value,
389 Register scratch,
408 Register object,
409 Register map,
410 Register dst,
418 Register object,
419 Register address,
420 Register value,
435 void CheckAccessGlobalProxy(Register holder_reg,
436 Register scratch,
439 void GetNumberHash(Register reg0, Register scratch);
442 Register elements,
443 Register key,
444 Register result,
445 Register reg0,
446 Register reg1,
447 Register reg2);
495 Register result,
496 Register scratch1,
497 Register scratch2,
501 void Allocate(Register object_size,
502 Register result,
503 Register scratch1,
504 Register scratch2,
512 void UndoAllocationInNewSpace(Register object, Register scratch);
515 void AllocateTwoByteString(Register result,
516 Register length,
517 Register scratch1,
518 Register scratch2,
519 Register scratch3,
521 void AllocateOneByteString(Register result, Register length,
522 Register scratch1, Register scratch2,
523 Register scratch3, Label* gc_required);
524 void AllocateTwoByteConsString(Register result,
525 Register length,
526 Register scratch1,
527 Register scratch2,
529 void AllocateOneByteConsString(Register result, Register length,
530 Register scratch1, Register scratch2,
532 void AllocateTwoByteSlicedString(Register result,
533 Register length,
534 Register scratch1,
535 Register scratch2,
537 void AllocateOneByteSlicedString(Register result, Register length,
538 Register scratch1, Register scratch2,
544 void AllocateHeapNumber(Register result,
545 Register scratch1,
546 Register scratch2,
547 Register heap_number_map,
551 void AllocateHeapNumberWithValue(Register result,
553 Register scratch1,
554 Register scratch2,
561 void instr(Register rd, Register rs, const Operand& rt); \
562 void instr(Register rd, Register rs, Register rt) { \
565 void instr(Register rs, Register rt, int32_t j) { \
570 void instr(Register rs, const Operand& rt); \
571 void instr(Register rs, Register rt) { \
574 void instr(Register rs, int32_t j) { \
579 void instr(Register rd_hi, Register rd_lo, Register rs, const Operand& rt); \
580 void instr(Register rd_hi, Register rd_lo, Register rs, Register rt) { \
583 void instr(Register rd_hi, Register rd_lo, Register rs, int32_t j) { \
621 void mov(Register rd, Register rt) { or_(rd, rt, zero_reg); }
623 void Ulw(Register rd, const MemOperand& rs);
624 void Usw(Register rd, const MemOperand& rs);
627 void li(Register rd, Operand j, LiFlags mode = OPTIMIZE_SIZE);
628 inline void li(Register rd, int32_t j, LiFlags mode = OPTIMIZE_SIZE) {
631 void li(Register dst, Handle<Object> value, LiFlags mode = OPTIMIZE_SIZE);
642 void push(Register src) {
646 void Push(Register src) { push(src); }
653 void Push(Register src1, Register src2) {
660 void Push(Register src1, Register src2, Register src3) {
668 void Push(Register src1, Register src2, Register src3, Register src4) {
676 void Push(Register src, Condition cond, Register tst1, Register tst2) {
691 void pop(Register dst) {
695 void Pop(Register dst) { pop(dst); }
698 void Pop(Register src1, Register src2) {
706 void Pop(Register src1, Register src2, Register src3) {
723 void StoreToSafepointRegisterSlot(Register src, Register dst);
726 void LoadFromSafepointRegisterSlot(Register dst, Register src);
731 void FlushICache(Register address, unsigned instructions);
734 void Ins(Register rt, Register rs, uint16_t pos, uint16_t size);
735 void Ext(Register rt, Register rs, uint16_t pos, uint16_t size);
742 void Cvt_d_uw(FPURegister fd, Register rs, FPURegister scratch);
746 void Trunc_uw_d(FPURegister fd, Register rs, FPURegister scratch);
758 void Mthc1(Register rt, FPURegister fs);
764 void Mfhc1(Register rt, FPURegister fs);
790 Register result,
792 Register scratch,
794 Register except_flag,
804 void TryInlineTruncateDoubleToI(Register result,
811 void TruncateDoubleToI(Register result, DoubleRegister double_input);
816 void TruncateHeapNumberToI(Register result, Register object);
822 void TruncateNumberToI(Register object,
823 Register result,
824 Register heap_number_map,
825 Register scratch,
831 void LoadNumber(Register object,
833 Register heap_number_map,
834 Register scratch,
842 void LoadNumberAsInt32Double(Register object,
844 Register heap_number_map,
845 Register scratch1,
846 Register scratch2,
855 void LoadNumberAsInt32(Register object,
856 Register dst,
857 Register heap_number_map,
858 Register scratch1,
859 Register scratch2,
873 Register arg_count,
883 void LoadContext(Register dst, int context_chain_length);
892 Register map_in_out,
893 Register scratch,
896 void LoadGlobalFunction(int index, Register function);
900 void LoadGlobalFunctionInitialMap(Register function,
901 Register map,
902 Register scratch);
914 void InvokeCode(Register code,
922 void InvokeFunction(Register function,
927 void InvokeFunction(Register function,
940 void IsObjectJSObjectType(Register heap_object,
941 Register map,
942 Register scratch,
945 void IsInstanceJSObjectType(Register map,
946 Register scratch,
949 void IsObjectJSStringType(Register object,
950 Register scratch,
953 void IsObjectNameType(Register object,
954 Register scratch,
973 void Throw(Register value);
977 void ThrowUncatchable(Register value);
980 void CopyFields(Register dst, Register src, RegList temps, int field_count);
985 void CopyBytes(Register src,
986 Register dst,
987 Register length,
988 Register scratch);
993 void InitializeFieldsWithFiller(Register start_offset,
994 Register end_offset,
995 Register filler);
1005 void TryGetFunctionPrototype(Register function,
1006 Register result,
1007 Register scratch,
1011 void GetObjectType(Register function,
1012 Register map,
1013 Register type_reg);
1017 void CheckFastElements(Register map,
1018 Register scratch,
1023 void CheckFastObjectElements(Register map,
1024 Register scratch,
1029 void CheckFastSmiElements(Register map,
1030 Register scratch,
1036 void StoreNumberToDoubleElements(Register value_reg,
1037 Register key_reg,
1038 Register elements_reg,
1039 Register scratch1,
1040 Register scratch2,
1041 Register scratch3,
1049 void CompareMapAndBranch(Register obj,
1050 Register scratch,
1058 void CompareMapAndBranch(Register obj_map,
1068 void CheckMap(Register obj,
1069 Register scratch,
1075 void CheckMap(Register obj,
1076 Register scratch,
1084 void DispatchMap(Register obj,
1085 Register scratch,
1094 Condition IsObjectStringType(Register obj,
1095 Register type,
1096 Register result) {
1106 // Register use:
1109 void IndexFromHash(Register hash, Register index);
1112 void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
1113 void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
1119 Register object,
1121 Register scratch1,
1122 Register scratch2,
1123 Register heap_number_map,
1130 void SmiToDoubleFPURegister(Register smi,
1132 Register scratch1);
1139 void AdduAndCheckForOverflow(Register dst,
1140 Register left,
1141 Register right,
1142 Register overflow_dst,
1143 Register scratch = at);
1145 void SubuAndCheckForOverflow(Register dst,
1146 Register left,
1147 Register right,
1148 Register overflow_dst,
1149 Register scratch = at);
1152 Register overflow_check,
1158 Register overflow_check,
1163 void RetOnOverflow(Register overflow_check, BranchDelaySlot bd = PROTECT) {
1167 void RetOnNoOverflow(Register overflow_check, BranchDelaySlot bd = PROTECT) {
1184 #define COND_ARGS Condition cond = al, Register rs = zero_reg, \
1246 Register scratch);
1248 Register scratch);
1260 void CallCFunction(Register function, int num_arguments);
1264 void CallCFunction(Register function,
1282 void CallApiFunctionAndReturn(Register function_address,
1300 void GetBuiltinEntry(Register target, Builtins::JavaScript id);
1303 void GetBuiltinFunction(Register target, Builtins::JavaScript id);
1318 void TruncatingDiv(Register result, Register dividend, int32_t divisor);
1324 Register scratch1, Register scratch2);
1326 Register scratch1, Register scratch2);
1328 Register scratch1, Register scratch2);
1336 void Assert(Condition cc, BailoutReason reason, Register rs, Operand rt);
1337 void AssertFastElements(Register elements);
1340 void Check(Condition cc, BailoutReason reason, Register rs, Operand rt);
1359 void JumpIfNotPowerOfTwoOrZero(Register reg,
1360 Register scratch,
1366 void SmiTag(Register reg) {
1371 void SmiTagCheckOverflow(Register reg, Register overflow);
1372 void SmiTagCheckOverflow(Register dst, Register src, Register overflow);
1374 void SmiTag(Register dst, Register src) {
1381 void TrySmiTag(Register reg, Register scratch, Label* not_a_smi) {
1384 void TrySmiTag(Register dst,
1385 Register src,
1386 Register scratch,
1393 void SmiUntag(Register reg) {
1397 void SmiUntag(Register dst, Register src) {
1402 inline void SmiTst(Register value, Register scratch) {
1405 inline void NonNegativeSmiTst(Register value, Register scratch) {
1411 void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case);
1415 void UntagAndJumpIfNotSmi(Register dst, Register src, Label* non_smi_case);
1418 void JumpIfSmi(Register value,
1420 Register scratch = at,
1424 void JumpIfNotSmi(Register value,
1426 Register scratch = at,
1430 void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi);
1432 void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi);
1435 void AssertNotSmi(Register object);
1436 void AssertSmi(Register object);
1439 void AssertString(Register object);
1442 void AssertName(Register object);
1446 void AssertUndefinedOrAllocationSite(Register object, Register scratch);
1450 void AssertIsRoot(Register reg, Heap::RootListIndex index);
1455 void JumpIfNotHeapNumber(Register object,
1456 Register heap_number_map,
1457 Register scratch,
1468 void LookupNumberStringCache(Register object,
1469 Register result,
1470 Register scratch1,
1471 Register scratch2,
1472 Register scratch3,
1478 Register first_object_instance_type, Register second_object_instance_type,
1479 Register scratch1, Register scratch2, Label* failure);
1483 void JumpIfInstanceTypeIsNotSequentialOneByte(Register type, Register scratch,
1486 void JumpIfNotUniqueNameInstanceType(Register reg, Label* not_unique_name);
1488 void EmitSeqStringSetCharCheck(Register string,
1489 Register index,
1490 Register value,
1491 Register scratch,
1496 void JumpIfNonSmisNotBothSequentialOneByteStrings(Register first,
1497 Register second,
1498 Register scratch1,
1499 Register scratch2,
1504 void JumpIfNotBothSequentialOneByteStrings(Register first, Register second,
1505 Register scratch1,
1506 Register scratch2,
1509 void ClampUint8(Register output_reg, Register input_reg);
1511 void ClampDoubleToUint8(Register result_reg,
1516 void LoadInstanceDescriptors(Register map, Register descriptors);
1517 void EnumLength(Register dst, Register map);
1518 void NumberOfOwnDescriptors(Register dst, Register map);
1521 void DecodeField(Register dst, Register src) {
1526 void DecodeField(Register reg) {
1531 void DecodeFieldToSmi(Register dst, Register src) {
1548 void DecodeFieldToSmi(Register reg) {
1561 void PatchRelocatedValue(Register li_location,
1562 Register scratch,
1563 Register new_value);
1565 void GetRelocatedValue(Register li_location,
1566 Register value,
1567 Register scratch);
1571 void CheckEnumCache(Register null_value, Label* call_runtime);
1580 Register receiver_reg,
1581 Register scratch_reg,
1586 void JumpIfJSArrayHasAllocationMemento(Register receiver_reg,
1587 Register scratch_reg,
1596 void JumpIfDictionaryInPrototypeChain(Register object, Register scratch0,
1597 Register scratch1, Label* found);
1600 void CallCFunctionHelper(Register function,
1605 void BranchAndLinkShort(int16_t offset, Condition cond, Register rs,
1609 void BranchAndLinkShort(Label* L, Condition cond, Register rs,
1620 Register code_reg,
1630 void InitializeNewString(Register string,
1631 Register length,
1633 Register scratch1,
1634 Register scratch2);
1637 void InNewSpace(Register object,
1638 Register scratch,
1645 inline void GetMarkBits(Register addr_reg,
1646 Register bitmap_reg,
1647 Register mask_reg);
1655 MemOperand SafepointRegisterSlot(Register reg);
1656 MemOperand SafepointRegistersAndDoublesSlot(Register reg);