Is it possible to implement subroutine call without a stack nor indirect addressing?

Question

is it possible to use subroutine with a cpu that doesn't feature indirect addressing nor a way to store the program counter, it would only feature :

• 2 register A and B ( and a status register for carry and zero flag)

• And those instructions:

  • load the A register with an address as operand

  • store the A register with an address as operand

  • load an immediate value into the A register

  • move the A register into the B register

  • move the B register into the A register

  • add A to B and store the result in A

  • sub B from A and stoee the result in A

  • nand A with B

  • nor a with B

  • branch if carry with a target address as operand

  • branch if zero with a target address as operand

  • jump with a target address as operand

  • halt the cpu

  • nop (do nothing for a clock cycle)

The problem is, to return from a subroutine you have to store the program counter somewhere first when you call it and the instruction set doesn't allow me to do this also with indirect addressing I can't return to a variable address.

Is it even possible to implement some sort of subroutine without self modifying code (or using an assembler to keep count of which instruction we are at)?

Answer 1

Evaluation of JC and JZ conditional jumps allow a form of "hack" where subroutines can hardcode four return addresses. The two flags, one bit each, are two bit. Two bits are four possible combinations: 00, 01, 10, 11. These are for the flags C:0 and Z:0, C:0 and Z:1, C:1 and Z:0, C:1 and Z:1.

These sequences at the end of the subroutine evaluate those four conditions, and branch to four different return addresses ("RTN" means the hardcoded return address specified in operand. )

1: JC,5
2: JZ,4
3: JPM,RTN
4: JPM,RTN
5: JZ,7
6: JPM,RTN
7: JMP,RTN

If JC,5 is 0, it continues to JZ,4. If JZ,4 is 0, it picks the first return address. If JC,5 is 0 but JZ,4 is 1, it picks the second return address. If JC,5 is 1 and JZ,7 is 0, it picks the third return address. If JC,5 is 1, and JZ,7 is 1, it picks the fourth address.

A "subroutine" is just when a sequence of instructions that is part of a normal program is able to be reused, thanks to that different return addresses can be specified. So, if JC, JZ and JMP allows four different return addresses, it seems like that would implement a very limited form of subroutines, using the constraints specified in the question.

I am a beginner, and I thought this was interesting to think about, but this "hack" was my initial thought from the question.