Why does the Z22 have a read-only shadow of the return address location?

Question

For some context to this question see Raffzahn's excellent question and answer How were Zuse Z22 Instructions Encoded?.

---

The Z22 treats the first few locations of its address space in a particular way:

• the instruction encoding gives preferential treatment to the encoding of addresses in this range, a little like a register file
• it is not backed by the (slow) memory drum, but some of it is backed by fast core memory.
• Some of the locations have special meanings, such as having a constant value when reading, or having the ability to test some of the bits for conditional execution, or I/O ports.

The Z22 instruction word has a bit you can set (it's called F), to copy the already-incremented program counter to Location 5. And any instruction can do this as a side effect, but I imagine it's most often combined with a E, which is the jump instruction, so that FE would be a subroutine call, having the return address in Location 5. So I guess to return from a subroutine you'd do EG 5 or something.

It's a bit like subroutine call/return on ARM, where you can call a subroutine with bl somewhere and return with bx lr, except that the return address is stored in a fixed location in memory instead of a register, and that any instruction can store the program counter to Location 5, not just branches.

Now we know that Location 5 is written to by the F operation. Another funky location in this portion of the address space in Location 16, which is a read-only shadow of Location 5. And this question asks what purpose that serves.

I suppose we can rule out the possibility of incomplete address decoding, since the binary values for 5 and 16 don't share any common 1s. Also none of the other locations have this kind of shadowing so far as I know. So it was deliberately put in, along with write-protection. So what is it for?

Answer 1

In simple, early instruction sets, saving the program counter and doing arithmetic on it wasn't rare.

One might, for example, embed some data in the program just after a subroutine call, use the return address to find the data for use by the subroutine, and increment the return address to just past the data so that you could return to the right instruction. This seems like madness nowadays, but we are used to much more capable computers with well-defined calling conventions and memory organisations.

Location 16 might have several purposes, and the question isn't quite clear on its behaviour.

• If location 16 is a read-only copy of the value that was stored into location 5 by the last subroutine call, then it is probably a method of ensuring that the original return address remains available.

• If location 16 is always a copy of location 5, updated immediately by hardware when location 5 changes, then its purpose is less obvious. It might be provided for use by instructions that alter the location they read.