Re: branch address architecture, not interactive use, The Design of Design

John Levine wrote:

According to Thomas Koenig  <tkoenig@netcologne.de>:

Do we know who invented relative branches? The PDP-11 had them in 1969
but I don't think they were new then.

I am just trying to make sense of the little documentation there
is of the PDP-X, and it seems it would have had PC- relative
branches too (but also branches relative to index registers),
either with an 8-bit or a 16-bit offset.  The Nova had something
similar, but only jumps relative to PC or its index registers,
the PDP-11 went to relative-only branches.

This draft is pretty clear:

https://bitsavers.org/pdf/dec/pdp-x/29_Nov67.pdf

It had both short page 0 addressing like the PDP-8 and short relative
long and short indexed.

I'd now say relative branches were obvious once you got to the point
where the cost of the addition to the PC wasn't a big deal, so they
probably occurred to a lot of people around the same time.

This was about the time where new architectures were being designed where having an I-Cache was assumed.
----------------------------------------------------------------------

The PDP-11 had short relative branches and a long jump that could use
any address mode that made sense, typically absolute or indirect. The
Unix assembler had conditional jump pseudo-ops that turned into a
branch if the target was close enough or a reverse branch around a
jump otherwise. If you allow chaining branches to the same place,
coming up with an optimal set of long and short is NP complete. If you
just do long and short, you can get close enough by starting with
everything long and making passes over the code shortening the ones
you can until you can't shorten anything else. (I did that for the AIX
ROMP assembler, same deal.)

This is exactly what the Mc 88100 linker did--the compiler emitted
unresolved branches as long and the linker shortened them up when
it was found to be in range.
----------------------------------------------------------------------

You could do some funky things with PDP-11 jumps like

  JMP @(R4)+

which dispatched to the next routine of threaded code pointed to by R4.

    JSR PC,@(SP)+
Popped the return address off the stack, pushed another return address on
the stack and transfers control. This is how we did coroutines.