Previous: Function Call, Up: Required VOPS [Contents]
Calling VOP’s are a cross product of the following sets (with some members missing): Return values multiple (all values) fixed (calling with unknown values conventions, wanting a certain number.) known (only in local call where caller/callee agree on number of values.) tail (doesn’t return but does tail call) What function local named (going through symbol, like full but stash fun name for error sys) full (have a function) Args fixed (number of args are known at compile-time) variable (MULTIPLE-VALUE-CALL and APPLY)
Note on all jumps for calls and returns that we want to put some instruction in the jump’s delay slot(s).
Register usage at the time of the call:
LEXENV This holds the lexical environment to use during the call if it’s a closure, and it is undefined otherwise.
CNAME This holds the symbol for a named call and garbage otherwise.
OCFP This holds the frame pointer, which the system restores upon return. The callee saves this if necessary; this is passed as a pseudo-argument.
A0 ... An These holds the first n+1 arguments.
NARGS This holds the number of arguments, as a fixnum.
LRA This holds the lisp-return-address object which indicates where to return. For a tail call, this retains its current value. The callee saves this if necessary; this is passed as a pseudo-argument.
CODE This holds the function object being called.
CSP The caller ignores this. The callee sets it as necessary based on CFP.
CFP This holds the callee’s frame pointer. Caller sets this to the new frame pointer, which it remembered when it started computing arguments; this is CSP if there were no stack arguments. For a tail call CFP retains its current value.
NSP The system uses this within a single function. A function using NSP must allocate and deallocate before returning or making a tail call.
Register usage at the time of the return for single value return, which goes with the unknown-values convention the caller used.
A0 This holds the value.
CODE This holds the lisp-return-address at which the system continues executing.
CSP This holds the CFP. That is, the stack is guaranteed to be clean, and there is no code at the return site to adjust the CSP.
CFP This holds the OCFP.
Additional register usage for multiple value return:
NARGS This holds the number of values returned.
A0 ... An These holds the first n+1 values, or NIL if there are less than n+1 values.
CSP Returner stores CSP to hold its CFP + NARGS * <address units per word>
OCFP Returner stores this as its CFP, so the returnee has a handle on either the start of the returned values on the stack.
ALLOCATE FULL CALL FRAME.
If the number of call arguments (passed to the VOP as an info argument) indicates that there are stack arguments, then it makes some callee frame for arguments:
VOP-result <- CSP CSP <- CSP + value of VOP info arg times address units per word.
In a call sequence, move some arguments to the right places.
There’s a variety of MOVE-ARGUMENT VOP’s.
FULL CALL VOP’S (variations determined by whether it’s named, it’s a tail call, there is a variable arg count, etc.)
if variable number of arguments
NARGS <- (CSP - value of VOP argument) shift right by address units per word.
A0...An <- values off of VOP argument (just fill them all)
else
NARGS <- value of VOP info argument (always a constant)
if tail call
OCFP <- value from VOP argument
LRA <- value from VOP argument
CFP stays the same since we reuse the frame
NSP <- NFP
else
OCFP <- CFP
LRA <- compute LRA by adding an assemble-time determined constant to
CODE.
CFP <- new frame pointer (remembered when starting to compute args)
This is CSP if no stack args.
when (current-nfp-tn VOP-self-pointer)
stack-temp <- NFP
if named
CNAME <- function symbol name
the-fun <- function object out of symbol
LEXENV <- the-fun (from previous line or VOP argument)
CODE <- function-entry (the first word after the-fun)
LIP <- calc first instruction addr (CODE + constant-offset)
jump and run off temp
<emit Lisp return address data-block>
<default and move return values OR receive return values>
when (current-nfp-tn VOP-self-pointer)
NFP <- stack-temp
Callee:
XEP-ALLOCATE-FRAME
emit function header (maybe initializes offset back to component start,
but other pointers are set up at load-time. Pads
to dual-word boundary.)
CSP <- CFP + compile-time determined constant (frame size)
if the function uses the number stack
NFP <- NSP
NSP <- NSP + compile-time determined constant (number stack frame size)
SETUP-ENVIRONMENT (either use this or the next one) CODE <- CODE - assembler-time determined offset from function-entry back to the code data-block address.
SETUP-CLOSURE-ENVIRONMENT (either use this or the previous one) After this the CLOSURE-REF VOP can reference closure variables. VOP-result <- LEXENV CODE <- CODE - assembler-time determined offset from function-entry back to the code data-block address.
Return VOP’s RETURN and RETURN-MULTIPLE are for the unknown-values return convention. For some previous caller this is either it wants n values (and it doesn’t know how many are coming), or it wants all the values returned (and it doesn’t know how many are coming).
RETURN (known fixed number of values, used with the unknown-values convention in the caller.) When compiler invokes VOP, all values are already where they should be; just get back to caller.
when (current-nfp-tn VOP-self-pointer)
;; The number stack grows down in memory.
NSP <- NFP + number stack frame size for calls within the currently
compiling component
times address units per word
CODE <- value of VOP argument with LRA
if VOP info arg is 1 (number of values we know we're returning)
CSP <- CFP
LIP <- calc target addr
(CODE + skip over LRA header word + skip over address units per branch)
(The branch is in the caller to skip down to the MV code.)
else
NARGS <- value of VOP info arg
nil out unused arg regs
OCFP <- CFP (This indicates the start of return values on the stack,
but you leave space for those in registers for convenience.)
CSP <- CFP + NARGS * address-units-per-word
LIP <- calc target addr (CODE + skip over LRA header word)
CFP <- value of VOP argument with OCFP
jump and run off LIP
RETURN-MULTIPLE (unknown number of values, used with the unknown-values convention in the caller.) When compiler invokes VOP, it gets TN’s representing a pointer to the values on the stack and how many values were computed.
when (current-nfp-tn VOP-self-pointer)
;; The number stack grows down in memory.
NSP <- NFP + number stack frame size for calls within the currently
compiling component
times address units per word
NARGS <- value of VOP argument
copy the args to the beginning of the current (returner's) frame.
Actually some go into the argument registers. When putting the rest at
the beginning of the frame, leave room for those in the argument registers.
CSP <- CFP + NARGS * address-units-per-word
nil out unused arg regs
OCFP <- CFP (This indicates the start of return values on the stack,
but you leave space for those in registers for convenience.)
CFP <- value of VOP argument with OCFP
CODE <- value of VOP argument with LRA
LIP <- calc target addr (CODE + skip over LRA header word)
jump and run off LIP
Returnee The call VOP’s call DEFAULT-UNKNOWN-VALUES or RECEIVE-UNKNOWN-VALUES after spitting out transfer control to get stuff from the returner.
DEFAULT-UNKNOWN-VALUES (We know what we want and we got something.) If returnee wants one value, it never does anything to deal with a shortage of return values. However, if start at PC, then it has to adjust the stack pointer to dump extra values (move OCFP into CSP). If it starts at PC+N, then it just goes along with the “want one value, got it” case. If the returnee wants multiple values, and there’s a shortage of return values, there are two cases to handle. One, if the returnee wants fewer values than there are return registers, and we start at PC+N, then it fills in return registers A1..A<desired values necessary>; if we start at PC, then the returnee is fine since the returning conventions have filled in the unused return registers with nil, but the returnee must adjust the stack pointer to dump possible stack return values (move OCFP to CSP). Two, if the returnee wants more values than the number of return registers, and it starts at PC+N (got one value), then it sets up returnee state as if an unknown number of values came back:
A0 has the one value
A1..An get nil
NARGS gets 1
OCFP gets CSP, so general code described below can move OCFP into CSP
If we start at PC, then branch down to the general ``got k values, wanted n''
code which takes care of the following issues:
If k < n, fill in stack return values of nil for shortage of return
values and move OCFP into CSP
If k >= n, move OCFP into CSP
This also restores CODE from LRA by subtracting an assemble-time constant.
RECEIVE-UKNOWN-VALUES (I want whatever I get.) We want these at the end of our frame. When the returnee starts at PC, it moves the return value registers to OCFP..OCFP[An] ignoring where the end of the stack is and whether all the return value registers had values. The returner left room on the stack before the stack return values for the register return values. When the returnee starts at PC+N, bump CSP by 1 and copy A0 there. This also restores CODE from LRA by subtracting an assemble-time constant.
Local call
There are three flavors: 1] KNOWN-CALL-LOCAL Uses known call convention where caller and callee agree where all the values are, and there’s a fixed number of return values. 2] CALL-LOCAL Uses the unknown-values convention, but we expect a particular number of values in return. 3] MULTIPLE-CALL-LOCAL Uses the unknown-values convention, but we want all values returned.
ALLOCATE-FRAME
If the number of call arguments (passed to the VOP as an info argument) indicates that there are stack arguments, then it makes some callee frame for arguments:
VOP-result1 <- CSP
CSP <- CSP + control stack frame size for calls within the currently
compiling component
times address units per word.
when (callee-nfp-tn <VOP info arg holding callee>)
;; The number stack grows down.
;; May have to round to dual-word boundary if machines C calling
;; conventions demand this.
NSP <- NSP - number stack frame size for calls within the currently
compiling component
times address units per word
VOP-result2 <- NSP
KNOWN-CALL-LOCAL, CALL-LOCAL, MULTIPLE-CALL-LOCAL KNOWN-CALL-LOCAL has no need to affect CODE since CODE is the same for the caller/returnee and the returner. This uses KNOWN-RETURN. With CALL-LOCAL and MULTIPLE-CALL-LOCAL, the caller/returnee must fixup CODE since the callee may do a tail full call. This happens in the code emitted by DEFAULT-UNKNOWN-VALUES and RECEIVE-UNKNOWN-VALUES. We use these return conventions since we don’t know what kind of values the returner will give us. This could happen due to a tail full call to an unknown function, or because the callee had different return points that returned various numbers of values.
when (current-nfp-tn VOP-self-pointer) ;Get VOP self-pointer with ;DEFINE-VOP switch :vop-var. stack-temp <- NFP CFP <- value of VOP arg when (callee-nfp-tn <VOP info arg holding callee>) <where-callee-wants-NFP-tn> <- value of VOP arg <where-callee-wants-LRA-tn> <- compute LRA by adding an assemble-time determined constant to CODE. jump and run off VOP info arg holding start instruction for callee <emit Lisp return address data-block> <case call convention known: do nothing call: default and move return values multiple: receive return values > when (current-nfp-tn VOP-self-pointer) NFP <- stack-temp
KNOWN-RETURN
CSP <- CFP
when (current-nfp-tn VOP-self-pointer)
;; number stack grows down in memory.
NSP <- NFP + number stack frame size for calls within the currently
compiling component
times address units per word
LIP <- calc target addr (value of VOP arg + skip over LRA header word)
CFP <- value of VOP arg
jump and run off LIP
Previous: Function Call, Up: Required VOPS [Contents]