New subject: Happy birthday, PDP-8!

27 Mar 2017

On 2017-03-27 04:00, Greg 'groggy' Lehey &lt;grog(a)lemis.com&gt; wrote:

...
  On Monday, 27 March 2017 at  6:49:30 +1100, Dave
Horsfall wrote:
  And as for subroutine calls on the -8, let's
not go there...  As I dimly
 recall, it planted the return address into the first word of the called
 routine and jumped to the second instruction; to return, you did an
 indirect jump to the first word.  Recursion?  What was that?  This was fairly
typical of the day.  I've used other machines (UNIVAC,
 Control Data) that did the same.  Later models added a second call
 method that stored the return address in a register instead, only
 marginally easier for recursion.

 At Uni I was given a relatively simple task to do in PDP-8 assembler:
 a triple precision routine (36 bits!) to clip a value to ensure it
 stayed between two limits.  Simple, eh?  Not on the PDP-8.  Three
 parameters, each three words long. only one register, no index
 registers.  I didn't finish it.  Revisiting now, I still don't know
 how to do it elegantly.  How *did* the PDP-8 pass parameters? 
This is probably extremely off-topic, so I'll keep it short.

This is actually very simple and straight forward on a PDP-8, but it 
might seem strange to people used to todays computers.

Essentially, you pass parameters in memory, as a part of the code 
stream. Also, the PDP-8 certainly do have index registers.

The first thing one must do is stop thinking of the AC as a register. 
The accumulator is the accumulator. Memory is registers.

Some memory locations autoincrement when used indirectly, they are 
called index registers.

That said, then. A simple example of a routine passing two parameters 
(well, three):

First the calling:

         CLA
         TAD   (42        / Setup AC with the value 42.
         JMS   COUNT
         BUFPTR
         BUFSIZ
         .                / Next instruction executed, with AC holding 
number of matching words in buffer.
         .

Now, this routine is expected to count the number of occurances of a 
specific word in a memory buffer with a specific size.
At calling, AC will contain the word to search for, while the address 
following the JMS holds the address, and the following address holds the 
size.

The routine:

COUNT,  0
         CIA
         DCA    CHR        / Save the negative of the word to search for.
         CMA
         TAD I  COUNT
         DCA    PTR        / Setup pointer to the address before the buffer.
         ISZ    COUNT      / Point to next argument.
         TAD I  COUNT
         CIA
         DCA    CNT        / Save negative value of size.
         DCA    RESULT     / Clear out result counter.
LOOP,   TAD I  PTR        / Get next word in buffer.
         TAD    CHR        / Compare to searched for word.
         SNA               / Skip if they are not equal.
         ISZ    RESULT     / Equal. Increment result counter.
         ISZ    CNT        / Increment loop counter.
         JMP    LOOP       / Repeat unless end of buffer.
         CLA               / All done. Get result.
         TAD    RESULT
         JMP I  COUNT      / Done.

PTR=10
CNT=20
CHR=21
RESULT=22

Addresses 10-17 are the index registers, so the TAD I PTR instruction 
will autoincrement the pointer everytime, and the increment happens 
before the defer, which is why the initial value should be one less than 
the buffer pointer.

Hopefully this gives enough of an idea, but unless you know the PDP-8 
well, you might be a little confused by the mnemonics.

As you can see, the return address at the start is used for more than 
just doing a return. It's also your argument pointer.

   Johnny

Re: [TUHS] Happy birthday, PDP-8!