Lines Matching defs:locals
252 // stack. The top of the callers stack is the bottom of the locals of the current
294 __ subptr(rax, wordSize); // need addition word besides locals[0]
397 const Register locals,
401 // On entry the "locals" argument points to locals[0] (or where it would be in case no locals in
406 // expression stack and this will overlap with locals[0] (and locals[1] if double/long) we must
408 // locals[0] and locals[1] do not exist (and in fact are return address and saved rbp). So when
409 // we are non-native we in essence ensure that locals[0-1] exist. We play an extra trick in
414 // Assumes locals == &locals[0]
459 // rsi/r13 == state/locals rax == prevstate
464 __ movptr(STATE(_locals), locals); // state->_locals = locals()
518 __ movptr(rax, Address(locals, 0)); // get receiver (assume this is frequent case)
626 __ movptr(rdi, Address(state, byte_offset_of(BytecodeInterpreter, _locals))); // get locals pointer
633 // see if we've got enough room on the stack for locals plus overhead.
640 // rdx: number of additional locals this frame needs (what we must check)
645 // rdi: &locals[0]
646 // rcx: # of locals
647 // rdx: number of additional locals this frame needs (what we must check)
653 // NOTE: since the additional locals are also always pushed (wasn't obvious in
684 // locals + overhead, in bytes
708 // Add stack base to locals and subtract stack size
985 // rsi/r13 == state/locals rdi == prevstate
986 const Register locals = rdi;
994 // for natives the size of locals is zero
996 // compute beginning of parameters /locals
997 __ lea(locals, Address(rsp, rcx, Address::times_ptr, -wordSize));
1004 // IN(locals) -> locals
1014 generate_compute_interpreter_state(state, locals, rcx, true);
1329 // preserved and correspond to the bcp/locals pointers.
1672 const Register locals = rdi;
1699 __ load_unsigned_short(rdx, size_of_locals); // get size of locals in words
1701 __ subptr(rdx, rcx); // rdx = no. of additional locals
1703 // see if we've got enough room on the stack for locals plus overhead.
1713 __ lea(locals, Address(rsp, rcx, Address::times_ptr, wordSize));
1724 // rdx - # of additional locals
1725 // allocate space for locals
1726 // explicitly initialize locals
1742 // IN(locals) -> locals
1748 generate_compute_interpreter_state(state, locals, rcx, false);
2061 [ extra locals ]
2261 return (extra_locals_size + // the addition space for locals
2272 intptr_t* locals,
2285 to_fill->_locals = locals;
2343 // If interpreter_frame!=NULL, set up the method, locals, and monitors.
2356 // calculates the extra locals based on itself. Not what the callee does
2393 // Find the locals pointer. This is rather simple on x86 because there is no
2395 // our locals based on the current fp().
2399 intptr_t* locals;
2400 // If the caller is interpreted we need to make sure that locals points to the first
2402 // because the stack to stack to converter needs a proper locals value in order to remove the
2408 // locals must agree with the caller because it will be used to set the
2412 locals = prev->stack() + method->size_of_parameters();
2413 // locals = caller->unextended_sp() + (method->size_of_parameters() - 1);
2414 if (locals != interpreter_frame->fp() + frame::sender_sp_offset + (method->max_locals() - 1) + 2) {
2418 // this is where a c2i would have placed locals (except for the +2)
2419 locals = interpreter_frame->fp() + frame::sender_sp_offset + (method->max_locals() - 1) + 2;
2432 locals,