Lines Matching defs:csp
130 if (rd.Is(csp)) {
134 Mov(csp, temp);
279 // If csp is an operand, add #0 is emitted, otherwise, orr #0.
998 // csp and reg_size is 32, registers must be pushed in blocks of four in order
999 // to maintain the 16-byte alignment for csp.
1016 // csp and reg_size is 32, registers must be pushed in blocks of four in
1017 // order to maintain the 16-byte alignment for csp.
1051 // stack pointer is csp and the register size is 32, registers must be pushed
1052 // in blocks of four in order to maintain the 16-byte alignment for csp.
1144 // to be pushed using csp, whilst maintaining 16-byte alignment for csp
1185 // registers to be popped using csp, whilst maintaining 16-byte alignment
1186 // for csp at all times.
1197 if (csp.Is(StackPointer())) {
1198 // If the current stack pointer is csp, then it must be aligned to 16 bytes
1208 // Even if the current stack pointer is not the system stack pointer (csp),
1217 if (csp.Is(StackPointer())) {
1218 // If the current stack pointer is csp, then it must be aligned to 16 bytes
1228 // It is safe to leave csp where it is when unwinding the JavaScript stack,
1283 // system stack pointer (csp).
1284 DCHECK(csp.Is(StackPointer()));
1286 MemOperand tos(csp, -2 * static_cast<int>(kXRegSize), PreIndex);
1307 // system stack pointer (csp).
1308 DCHECK(csp.Is(StackPointer()));
1310 MemOperand tos(csp, 2 * kXRegSize, PostIndex);
1330 if (csp.Is(StackPointer())) {
1331 // Always check the alignment of csp if ALWAYS_ALIGN_CSP is true. We
1332 // can't check the alignment of csp without using a scratch register (or
1335 ldr(xzr, MemOperand(csp, 0));
1337 if (FLAG_enable_slow_asserts && !csp.Is(StackPointer())) {
1339 // Check that csp <= StackPointer(), preserving all registers and NZCV.
1340 sub(StackPointer(), csp, StackPointer());
1341 cbz(StackPointer(), &ok); // Ok if csp == StackPointer().
1342 tbnz(StackPointer(), kXSignBit, &ok); // Ok if csp < StackPointer().
1347 sub(StackPointer(), csp, StackPointer());
1353 sub(StackPointer(), csp, StackPointer());
1363 ldr(temp, MemOperand(csp));
1860 // If the stack pointer is not csp, we need to derive an aligned csp from the
1863 if (!csp.Is(old_stack_pointer)) {
1876 Bic(csp, old_stack_pointer, sp_alignment - 1);
1877 SetStackPointer(csp);
1884 if (!csp.Is(old_stack_pointer)) {
1887 // aligned csp can be up to 12 bytes below the jssp. This is the case
1892 Sub(temp, csp, old_stack_pointer);
2190 DCHECK(!AreAliased(src, dst, csp));
2239 DCHECK(!current_address.Is(csp));
2678 if (csp.Is(old_stack_pointer)) {
2681 // cope with csp and have an extra parameter indicating which stack pointer
2683 Push(jssp, xzr); // Push xzr to maintain csp required 16-bytes alignment.
2684 Mov(jssp, csp);
2702 if (csp.Is(old_stack_pointer)) {
2703 Mov(csp, jssp);
2704 SetStackPointer(csp);
2886 DCHECK(csp.Is(StackPointer()));
2894 // csp[8]: Memory reserved for the caller if extra_space != 0.
2896 // csp -> csp[0]: Space reserved for the return address.
2902 Add(scratch, csp, kXRegSize);
2911 DCHECK(csp.Is(StackPointer()));
4154 // - x31 (csp) because the system stack pointer doesn't need to be included
4633 // Abort is used in some contexts where csp is the stack pointer. In order to
4853 if (!csp.Is(StackPointer())) {
4854 Bic(csp, StackPointer(), 0xf);
4897 if (!csp.Is(StackPointer())) {
4898 DCHECK(!csp.Aliases(arg0));
4899 DCHECK(!csp.Aliases(arg1));
4900 DCHECK(!csp.Aliases(arg2));
4901 DCHECK(!csp.Aliases(arg3));
4912 // If csp is the stack pointer, PushCPURegList asserts that the size of each
5003 __ sub(csp, csp, 4 * kXRegSize);
5087 DCHECK(!AreAliased(result, xzr, csp));
