Which Z80 opcodes can I use without a stack?

Question

Quick question, as the title implies. I'm in the process of writing an 'OS' for my DIY Z80 computer and one of the things I need to do to help debug any issues during the boot process is send a repeating sequence of data to an IO port in the event of a problem.

The problem I'm catering for is a very specific one where there is no RAM present - obviously this means no stack, either.

So what can I get away with in terms of program structure with no stack? I'm assuming a simple JP instruction and most opcodes that aren't CALL should work?

The code below doesn't seem to get executed - though this could be a problem specific to the failure mode of my setup, I just wanted to confirm that the code below will work with no stack?

Here's the error routine:

BOOT_ERROR:
            LD      A,C                 ; Move error code into E
            LD      E,A                 ;
            LD      A,%10101010         ; Load HALT code into L
            LD      L,A

bterr_lp:   LD      A,L                 ; Get code to display
            OUT     (BASIC_IO),A        ; Update error display
            LD      BC,$FFFF            ; Set delay (1 sec approx.)
bterr_plp:
            NEG                         ; 8 T-states
            NEG                         ; 8 T-states
            NEG                         ; 8 T-states
            NEG                         ; 8 T-states
            DEC     BC                  ; 6 T-states
            LD      A,C                 ; 9 T-states
            OR      B                   ; 4 T-states
            JP      NZ,bterr_plp        ; 10 T-states

            EX      DE,HL               ; Swap error code with HALT code
            JP      bterr_lp

Answer 1

All commands are allowed actually, whether you have RAM or not. It is just the consequences of some of the commands that you have to bear in mind. E.g., using CALL is fine even if you have no RAM, but you need to remember that your current PC will not be saved, that SP will still be decremented twice and that RET will simply return to whatever word in memory is currently pointed to by the SP.

More specifically, your code looks absolutely fine. Hence, I'd make sure you actually run it (Z80 executes from PC=0 after the restart - is this where your code is situated?) Also, interrupt processing is somewhat dangerous, especially in the IM 2 mode. If you allowed interrupts and have interrupts triggered by your hardware, the current PC won't be saved once again, and your interrupt processing code will have no default way of knowing where to return to after interrupt has been processed.

Oh, and by the way, using NEG for time-wasting is not particularly memory efficient, because you are getting 8 t-states per 2 bytes of memory. INC BC : DEC BC will give you 12 t-states in the same memory; PUSH HL : PUSH HL will take 22 t-states and only modify the value of SP.

Answer 2

If your design has no RAM, that doesn't mean you haven't got the stack. Stack is not a write-only "device", you can use it to read data as well. For example, you set SP to the table in ROM and then read data from there:

LD SP,table
POP HL
...do smth...
POP HL
...do smth...

Another option is to use table-driven jumps in the same way by using RET:

LD SP,jump_table
...
RET ;use first value from jump table

... somewhere in the code jumped to:
RET ;use second value from jump table

Answer 3

It's as obvious as you think: nothing other than CALL/RST, RET/RETI/RETN, PUSH, POP, EX (SP), HL/IX and the entry into interrupts should use the stack, and the code you've posted should be fine with no stack. Interrupts should be disabled upon reset to avoid a hardware race condition, but obviously NMIs can't be disabled so make sure you've got that input under control.

Maybe the first things to check is whether your assembler has compiled for the correct address, and that you're properly decoding for access to your ROM?