Lines Matching refs:Address
26 Address deopt_handler = Runtime::FunctionForId(
42 Address deopt_handler = Runtime::FunctionForId(
1134 // To let the GC traverse the return address of the exit frames, we need to
1135 // know where the return address is. The CEntryStub is unmovable, so
1136 // we can store the address on the stack to be able to find it again and
1150 // This is the return address of the exit frame.
1236 // a0: entry address
1369 __ ld(t9, MemOperand(a4)); // Deref address.
1681 // sp[4] : address of receiver argument
1746 // v0 = address of new object(s) (tagged)
1765 // v0 = address of new object (tagged)
1768 // a4 = address of arguments map (tagged)
1794 // v0 = address of new object (tagged)
1797 // a4 = address of parameter map or backing store (tagged)
1802 // Move backing store address to a3, because it is
1839 // a3 = address of backing store (tagged)
1840 // a4 = address of parameter map (tagged)
1841 // a5 = temporary scratch (a.o., for address calculation)
1861 // a3 = address of backing store (tagged)
1898 // Return address is in ra.
2217 // Stack pointer now points to cell where return address is to be written.
2219 // treat the return address as argument 5. Thus every argument after that
2236 // Argument 9: Pass current isolate address.
2260 // Argument 9: Pass current isolate address.
2860 __ stop("Unexpected code address");
2943 // Get the receiver of the function from the stack; 1 ~ return address.
3117 // ra: return address
3483 // -- ra : return address
3858 // Place the return address on the stack, making the call
3865 // In case of an error the return address may point to a memory area
3867 // Dereference the address and check for this.
4153 // written is in the address register.
4171 address(),
4198 __ ld(regs_.scratch0(), MemOperand(regs_.address(), 0));
4216 address(),
4236 Register address =
4237 a0.is(regs_.address()) ? regs_.scratch0() : regs_.address();
4238 DCHECK(!address.is(regs_.object()));
4239 DCHECK(!address.is(a0));
4240 __ Move(address, regs_.address());
4242 __ Move(a1, address);
4278 address(),
4289 __ ld(regs_.scratch0(), MemOperand(regs_.address(), 0));
4309 // We need extra registers for this, so we push the object and the address
4311 __ Push(regs_.object(), regs_.address());
4315 regs_.address(), // Scratch.
4317 __ Pop(regs_.object(), regs_.address());
4322 address(),
4331 __ Pop(regs_.object(), regs_.address());
4463 // Compute the function's address for the first argument.
4466 // The caller's return address is above the saved temporaries.
4485 // trampoline function at a known address.
4681 // -- sp[0] : return address
4747 // -- sp[0] : return address
4856 // Arguments is after the return address.
