On 2023-08-28 2:45 a.m., Michael J. Mahon wrote:
> Jeff Blakeney <
CUTjeffre...@yahoo.ca> wrote:
>> As far as I remember my 6502 assembly, when you do a JSR, the processor
>> has already read the JSR byte and the two byte address so the PC is
>> pointing at the DB CMDNUM statement and that is what is pushed on the
>> stack. The MLI pulls that address off the stack, adds 3 to it, pushes
>> it back on the stack and does an RTS so that the BNE ERROR statement
>> will get executed.
>>
>> In other words, the SYSCALL is the address of the JSR but it isn't the
>> address that gets pushed onto the stack when the JSR is executed.
>
> Well, the details are: JSR pushes the address of the JSR opcode plus *two*
> on the stack, and the RTS pops the address and adds *one* to get the return
> PC value.
I haven't done any 6502 coding in a long time but my memory tells me the
6502 did it this way: PC has address of SYSCALL (or probably SYSCALL-1
and increments the PC to get there), processor reads the byte there to
see what opcode to execute, sees it is a JSR so increments the PC and
reads the low byte of the address, increments the PC and reads the high
byte of the address, pushes the current PC (SYSCALL +2) to the stack,
changes the PC to the address it just read and continues execution from
there. When it hits an RTS it pulls the address off the stack, adds one
to it and continues executing from there.
> This doesn’t change the need to add 3 to the stacked value to skip 3 bytes
> of in-line data, but it does mean that the stacked address points at the
> high byte of the JSR, not the first byte of the in-lined data.
>
> Sometimes details matter. ;-)
Breaking it down above, I realized that I probably got it wrong in my
original post and the stack gets the address of the high byte and not
the address of the DB CMDNUM. Also it makes me wonder if the 6502
subtracts one from the JSR address when it puts it in the PC so that it
can be incremented before reading the opcode at the JSR address. It
depends on whether the 6502 always increments the PC before reading the
next opcode and my memory fails me on that point.
As to the original question, the 6502 pushes SYSCALL + 2 to the stack,
the MLI needs to add 3 to the address pulled off the stack, the 6502
adds 1 when it does the RTS so you end up continuing execution at
SYSCALL +6 in the example.
Knowing the details of how the 6502 works in this case isn't really
necessary, you just need to know that your code will continue executing
after the command block. :)