General Points

Domains provide (_entry blocks) to indicate which parameters to accept and where to accept them as control reaches the domain thru a gate.

The exit block of the jumper is used in conjunction with the entry block of the jumpee to determine action of the jump.

The Entry Block
If the gate is a start key or a return key the entry block for the jump is taken from floating register 2 of the jumpee. If the gate is a restart or fault key the entry block is zero. {No parameters are accepted in this case, but see (p1,jtrap) about fault keys.}

The entry block specifies the conditions that the program logic expects as the jumpee gains control after a gate jump. The entry block is examined only as the jumpee gains control and format errors are reported then.

The entry block forms are:

00R1 CDSL MMMM 0000 KKKK(*4)

"R" Parameter string to regs (regparm) "C" Order code request (recec) "D" Databyte request (accdb) "S" Parameter string request (pstring) "L" String length request (strl) "MMMM" Key parameter mask (keyparams) "KKKK" Key parameter slot numbers

A zero entry block is treated as X'10000000'.

See (p3,macros) for assembler macros that let you normally ignore the details here.

If bits of the entry block that are not specified to influence the jump are not zero, trap codes may or may not be produced. This depends only on the version of the kernel and does not depend on other information in the machine.

Data Parameters
Order Code
If bit 4 {C}, the order code will be placed in general register 1 of the jumpee. Otherwise, register 1 is unchanged. {See (p1,jtrap) about when E4 is zero and the order code isn't.}

Byte String Parameter and Parameter Page
{arcane}{This is an older method. It has been de-implemented.} If F=0 then the value V in bits 8 thru 19 of the entry block {LLLL(*3)} determine the parameter string length. An argument string will be accepted if V>0 and the jumpee's general key slot designated by bits 12 thru 15 {PPPP} holds a read-write page key. The argument string is copied beginning at byte 2 of this page. The length of the argument string {offered string} is placed in bytes 0 and 1 of that page {but see (p1,chpt)}. The first MIN(4094, V, argument length) bytes in the parameter page will be replaced by the beginning of the argument. {The parameter page key may designate the same page as the argument page key.}
If the parameter page key is not a read-write page key then no copy of the argument will be made and X'050000000004' will be placed as a trap code in the jumpee.

If (bit 6) = 1 {"S" in "CDSL"} then general registers 4 and 5 hold the address {in either the jumpee's virtual memory or the jumpee's registers} and length of the parameter string respectively.
If also bit 7 {"L" in "CDSL"} then the length of the argument string will be placed in general register 3. {But see (p1,chpt).}

If the argument string is shorter than the parameter string, the values at the end of the parameter string that were there before the jump will remain. If the argument is longer than the parameter the remainder of the argument is not transmitted.

If bit 2 is 0 then the parameter string is in the jumpee's virtual memory.

If bit 2 is 1 then the parameter string is in the jumpee's registers. For this purpose the 32 bytes of the floating registers 0 thru 6 are considered to follow and be contiguously adjacent to the 64 bytes of the general registers. If registers R4 and R5 describe a field not within the 96 bytes and the length of the received string is greater than zero, then the error code described at (c508) results.

Reg: R0 R1 ... R15 F0 ... F6 Addr: 0 4 ... 60 64 ... 88

The storage that holds the argument string need not be distinct from the storage that holds the parameter strings. The effect is as if the argument string were entirely fetched before any part is stored.

{arcane}See (p1,strdes) about this design.

The left byte of register 5 is not used. {We have not limited the parameter string length to 4096 although there now is no way to produce an argument longer than 4096.}

If some of the parameter string is in a page which is not defined read/write in the jumpee's address segment and the argument to be placed into that parameter is long enough, then an addressing trap code {(p1,parmlack)} will be produced in the jumpee even when a write reference to that address by a process in the jumpee would have caused a call to a segment keeper. No segment keeper will be called. It is as if the reference to the parameter string had been made via a memory key with a no-call bit. In this case the portion of the argument that belonged in the undefined page is not copied, but the rest of the jump action proceeds. See (p3,segkeeparmstr) for examples.

{arcane}LOOSE END: Improve this description.

Databyte of Key
If bit 5 is 1 then general register 2 of the jumpee is set to a value determined by the gate key. If the gate key is a start key the value is the databyte {(p2,crent)} of the start key with 24 high-order zeros. If the gate key is a resume key the value is zero.

Key Parameters
The jumpee specifies which of the four key arguments are to be accepted. For 0<=i<4 if (bit i+8) then the i'th key argument is accepted and placed in the jumpee's general key register specified by the bits 16 + 4*i thru 19 + 4*i. If bit i+8 is 0 then key argument i will not be received {and the corresponding slot will be unmodified}.

The slots designated to receive key parameters and to provide the parameter page key must be distinct.