🚀 go-pugleaf

A question for those old diehard dec fans...  We (WPI) used to have a
DECSYSTEM 20.  One interesting thing about the DEC 20 (and I guess DEC 10 and
pdp-6 as well) is that the registers are the first 8 or 16 locations in the
main memory map.  Does anyone know if code can be run in the registers?  And
if so, does it execute any faster than if it was in normal memory?

Here's some other interesting DEC 20 features for those who don't know:

	- Each address had an indirect bit.  Therefore you could do
	  infinite levels of indirections.  You can even crash your program
	  by having self indirections.

	- An address was calculated for all instructions.  Even those which
	  didn't use the address.

	- Since every instruction generates an address, DEC made user
	  definable instructions which were like software interrupts but which
	  had an addressing mode.

	- For debugging purposes you could trap page faults- that is, you
	  can have some code get executed each time a page virtual memory
	  page gets loaded.
	  There's a security flaw in one of the old versions of Tops-20- what
	  you did was place a password accross a page boundary.  Then you
	  call some O.S. function which required a password.  If the part
	  of the password which is before the page boundary is correct, then
	  you don't get a page fault.  You can use this to reduce password
	  searches from 96^8 to 96*8 character changes.

	- Some Tops-20 calls used 36-bit passwords.

	- There's an execute instructions which executes the instruction at
	  the calculated address.  (and yes, executing an execute instruction
	  got things very confused)

	- There's instructions for handling bytes of any arbitrary size less
	  than 36 bits (the world length).  You had to access these bytes
	  with special "byte pointers"

	- The family of computers which the DEC 20 was based didn't originally
	  use a stack.  There are a bunch of instructions which allow
	  subroutine calls to occure with linked lists instead of stacks.

	- The DEC 20 didn't really have CC bits and all instructions were 1
	  word long so the O.S. (Tops-20 aka. Twenex) indicated different
	  return conditions from O.S. calls by returning at different places.
	  So an error return might be the next instruction after the O.S. call
	  and a success condition would be 2 at 2 instructions after the O.S.
	  call.