Indirect calls with the Z80

Yep, I also use that method.

One thing I would wish for in the Z80 instruction set is if the indexed register indirect jump instructions also had offset support. jp ix + o would’ve really made polymorphic calls easier and cheaper to use. Now I always have to put the polymorphic call at the start of the object, but if you got more than one of them you have to fall back on more expensive methods.

Not sure if I mean the same, but you could use an addressing table at an address with the low part equal to 0 (##00h) and then select by:

ld hl, table
ld a, function_index
sla a
ld l, a
jp (hl)

Up to 128 functions could be pointed.

; Simply "jp [hl]", but can be used to emulate the instruction "call [hl]"
; param hl: address
JP_HL:
	jp	[hl]

As mentioned above it can be extended for all register pairs.

JP_HL:
	jp	[hl]
JP_BC:
	push bc
	ret
JP_DE:
	push de
	ret
JP_IX:
	jp	[ix]
JP_IY:
	jp	[iy]
JP_HL_S:
	exx
	push hl
	exx
	ret
JP_BC_S:
	exx
	push bc
	exx
	ret
JP_DE_S:
	exx
	push de
	exx
	ret

Could be convenient to have if you have callbacks that takes arguments in hl or other registers.
Tricky part is when your callback takes arguments in all registers, then it is probably easiest to resort to rewriting the call instruction. (Probably the faster option for everything but [hl])

ld hl, table
ld a, function_index
sla a
ld l, a
jp (hl)

ld de, table ; table base address
ld hl, (function_index) ; variable containing the function index to call
ld h, 0 ; if function_index is 8-bit
add hl, hl ; x2
add hl, de ; index from table begin
push hl ; set call address
ret ; indirect call

Are you sure about that code? Unless I'm missing something, it ends up executing the code at hl, not the code at the address pointed by hl...
For example: in a single entry table: dw $0000 it won't jump to $0000; it will execute two NOPs and then whatever is after the table...

My jump table routines actually look like this:

; -----------------------------------------------------------------------------
; Uses a jump table. Usage: both call JP_TABLE and jp JP_TABLE are valid
; param hl: jump table address
; param a: unsigned 0-based index (0, 1, 2...)
JP_TABLE:
	add	a ; a *= 2
; ------VVVV----falls through--------------------------------------------------

; -----------------------------------------------------------------------------
; Uses a jump table. Usage: both call JP_TABLE_2 and jp JP_TABLE_2 are valid
; param hl: jump table address
; param a: unsigned 0-based index (0, 2, 4...)
JP_TABLE_2:
	add	l ; hl += a
	ld	l, a
	adc	h
	sub	l
	ld	h, a
	; jr	JP_HL_INDIRECT ; (falls through)
; ------VVVV----falls through--------------------------------------------------

; -----------------------------------------------------------------------------
; Emulates the instruction "jp [[hl]]" or "call [[hl]]"
; param hl: pointer to the address
; touches a
JP_HL_INDIRECT:
	ld	a, [hl] ; hl = [hl]
	inc	hl
	ld	h, [hl]
	ld	l, a
	; jr	JP_HL ; (falls through)
; ------VVVV----falls through--------------------------------------------------

; -----------------------------------------------------------------------------
; Simply "jp [hl]", but can be used to emulate the instruction "call [hl]"
; param hl: address
JP_HL:
	jp	[hl]
; -----------------------------------------------------------------------------

I think you are right theNestruo!!

I'm a little lazy to calculate it now, but it'd also be nice to calculate how large should the jump table in order to justify this vs just a series dec/jr like:
ld a,(function_index)
or a
jr z,FUNCTION1
dec a
jr z,FUNCTION2
...
jr FUNCTIONn

I'm assuming that for 4 - 5 functions, just the list of "dec/jr z" is faster.