28 Mar
2017
28 Mar
'17
1:30 a.m.
On 2017-03-27 04:00, Greg 'groggy' Lehey <grog(a)lemis.com> wrote:
On Monday, 27 March 2017 at 6:49:30 +1100, Dave
Horsfall wrote:
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
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? 
28 Mar
28 Mar
1:33 a.m.
New subject: Happy birthday, PDP-8!
On Tue, 28 Mar 2017, Johnny Billquist wrote:
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
Actually, that reminds me of ProDOS-8 on the Apple ][, which uses a
similar mechanism to pass parameters.
-uso.
1:49 a.m.
New subject: Happy birthday, PDP-8!
And, as usual I have to correct myself a little, but I'll also tie in a
bit with (almost) Unix in doing so. :-)
On 2017-03-28 01:33, Steve Nickolas wrote:
Interesting. Since the Apple ][ used the 6502, I would have assumed it
used the stack, but I've never used the 6502 much, so I don't know if it
possibly can make sense to write code this way on that processor.
Speaking of which, when the PDP-11 was introduced, it wasn't obvious
that this style of coding wasn't sometimes appropriate, so the PDP-11
have the means of doing this as well.
If anyone ever wondered about the strangeness of the JSR instruction of
the PDP-11, it is precisely because of this.
What it does is that it pushes the argument register on the stack, loads
the PC into the argument register, and then sets the new PC.
So, if you use some other register than R7 as the argument to JSR, that
register then points to the word following the JSR, where you can have
your arguments. And you fetch them with indirect autoincrement, and at
the end you do an RTS with that same register, which at that point
points beyond the arguments you had. And the register used for the
argument pointer is restored by the RTS.
I've used it once or twice on a PDP-11, but this whole scheme only works
if I-space and D-space are the same, so there are limitations.
I doubt Unix ever used this, but maybe someone know of some obscure
inner kernel code that do. :-)
Johnny
On Tue, 28 Mar 2017, Johnny Billquist wrote:
[...]
> 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.
I knew I felt that something wasn't right, but it wasn't until I looked
at your reply, Steve, that I found what it was.
This SNA should have been SNA CLA...
> ISZ RESULT / Equal. Increment result
counter.
> ISZ CNT / Increment loop counter.
> JMP LOOP / Repeat unless end of buffer.
> CLA / All done. Get result.
and CLA should not have been there.
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
Actually, that reminds me of ProDOS-8 on the Apple ][, which uses a
similar mechanism to pass parameters.
2793
days inactive
2793
days old
2 comments
2 participants
participants (2)
-
Johnny Billquist -
Steve Nickolas