What methods for using control flow are there in 6502?

Question

I am trying to understand control flow in 6502 assembly.

Say I have the following code:

    ControlFlow:
      lda mem
      cmp #1
      bne .sub_one

      cmp #2
      bne .sub_two

      .sub_one:
        ; sub routine one goes here
        jmp .done ; <-------------- without this jmp, .sub_two will execute

      .sub_two:
       ; sub routine two goes here

      .done:

      rts

Personally, I would love a switch statement or some other control flow structure. The JMP above concerns me as well. It seems like there is a better way to handle multiple cases without this type of spaghetti code.

Um, you're programming in assembly language. You have to build all the fancy control structures yourself. If you want a control structure that somebody else has written, then use a high-level language. — Raymond Chen, Jan 19 '13 at 04:35

Aki Suihkonen · Answer 1 · 2013-01-20T09:26:18.753

5

Jump tables can be useful, if the number of cases is large enough. On the left, there's a template (untested) for jump to label that pushes the correct address to stack and returns. On the right there's a diff to jsr based routine, that will continue at the label _out: after returning from each subroutine. The carry logic is inverted on 6502, meaning that carry will be set if (Acc >= Imm).

; goto  label[n]   vs.         call label[n]

lda variable
cmp #MAX_PLUS_ONE                          
bcs _out
tax
lda table_hi, X
pha                vs.         sta jsrcmd+2
lda table_lo, X
pha                vs.         sta jsrcmd+1
rts                vs. jsrcmd: jsr 1000        ; self modify

_out:

edited Jan 20 '13 at 09:26

answered Jan 20 '13 at 09:20

Aki Suihkonen

19,144
1
36
57

Of course you could also expand the jump table such that invalid indexes jump to `out` directly. If your cases are sufficiently sparse you could write the index directly into a branch, branching into a carefully authored dispatch table. – JasonD Jan 20 '13 at 09:36
Yes, if the number of cases is known to be limited. Further improvements would dedicate 2 bytes from page zero for the table offset and ensure that each switch case label resides on the same page. Also in that case a self modifying relative address would be possible. – Aki Suihkonen Jan 20 '13 at 16:53
+1 (Heh, read this answer *after* adding my comment to the one above.) – Eight-Bit Guru Jan 22 '13 at 17:08
`table_hi` and `table_lo` in the example above must contain jump address _minus_ one. This is because `jsr` pushes not the return address itself, but return address minus one, hence `rts` adds one to the popped address before going there. – lvd Oct 23 '15 at 17:39

score 4 · Accepted Answer · answered Jan 19 '13 at 09:29

4

There is no better way actually but there might be an improvement like calling the FlowControl as a subroutine and returning with RTS.

This is the main flow.

  jsr ControlFlow
  ; main routine continues here

Here is the sub routine.

ControlFlow:
  lda mem
  cmp #1
  bne .sub_one
  cmp #2
  bne .sub_two
  cmp #3
  bne .sub_three
    ; case else here
  rts

  .sub_one:
    ; sub routine one goes here
  rts

  .sub_two:
   ; sub routine two goes here
  rts

  .sub_three:
   ; sub routine three goes here
  rts

if sub routines are too long, you need to use JMPs as mentioned before.

.jump_to_sub_one
  jmp .sub_one
.jump_to_sub_two
  jmp .sub_two
.jump_to_sub_three
  jmp .sub_three

ControlFlow:
  lda mem
  cmp #1
  bne .jump_to_sub_one
  cmp #2
  bne .jump_to_sub_two
  cmp #3
  bne .jump_to_sub_three
    ; case else here
  rts

  .sub_one:
    ; sub routine one goes here
  rts

  .sub_two:
   ; sub routine two goes here
  rts

  .sub_three:
   ; sub routine three goes here
  rts

That's how it is done and unfortunately, there is no better way. This applies to many assembly languages if not all.

answered Jan 19 '13 at 09:29

Emir Akaydın

5,708
1
29
57

That's a pretty inefficient way to construct the jump table, using many test+branch pairs. There are definitely better ways than that. – JasonD Jan 20 '13 at 09:40
1

JasonD, please share your alternative solution then we can discuss. Author was trying to get rid of end of routine jumps to avoid spagetti code and my solution shows how you do it. If he was trying branching in less cycles or shorter code, i'd give a different advice. What is your "definitely better way" for such scenerio? – Emir Akaydın Jan 22 '13 at 13:53
There are at least two improvements that I can think of off the top of my head; firstly, using ZP indirect addressing with the 'mem' value as an offset into a subroutine table eliminates the CMP series. Secondly, augmenting that technique with a table containing subroutine start addresses and using the stack to forge a return address before using RTS and allowing the CPU to 'return' to the appropriate subroutine entry-point. In both cases there is a storage overhead for the jump table, and some setup code to do the conditional jump is needed, but the result is a faster, cleaner technique. – Eight-Bit Guru Jan 22 '13 at 17:06
let's say you are writing a joystick control routine. you read the joystick input address (let's say $dc00 for commodore 64) and start comparing values for left, right, up, down, diagonal directions and fire. states are not incremental like 1,2,3... so you need a 256*2 = 512 byte table for possible cases like this or more lookup tables which makes things even more complex unlike the author asked for. ZP is limited with 256 bytes and even less for some machines like Commodore 64 (you are not allowed to use $01). so, your suggestion cannot be accepted as a general solution but a special case one – Emir Akaydın Jan 22 '13 at 17:25
@EmirAkaydın This is not a 'special case' solution; you've contrived a special case example to try to paint it as such, but in fact these concepts are generally applicable to a wide range of conditional-jump scenarios on all 6502-based machines. The specific choice of implementation depends on the problem, but for your example I would likely use logical mask operations to map joystick return values to something that can be managed without complex decode logic. If you *really* want special-case, how about tapping the BRK vector and sniffing the stack for the return address to jump to...? – Eight-Bit Guru Jan 23 '13 at 15:32
2

@Jonners, this is out of topic but please see my c64 profile here. http://csdb.dk/scener/?id=8375. as you can see there, i've worked on many 256 bytes intros and other products using 6502 based systems. your advice is a special case scenerio and a very nice optimization for sequential cases. author said "Personally, I would love a switch statement or some other control flow structure.". a switch statement doesn't guarantee sequential cases, does it? so, my answer is the correct answer for this question. if you want to extend it with special cases, go ahead. – Emir Akaydın Jan 23 '13 at 21:35
1

@EmirAkaydın Indeed, I wouldn't expect anyone answering this question to have less than at least a solid grounding in practical 6502 applications (I refer the honourable gentleman to my own profile here). The problem is that your answer is bracketed with the terms 'There is no better way' and 'unfortunately, there is no better way'. This is patently erroneous, since there are several better ways depending on the specific problem to be solved. – Eight-Bit Guru Jan 24 '13 at 10:05

score 3 · Answer 3 · answered Aug 18 '13 at 14:27

6502 provides the following to control program flow, i.e. modify the PC register.

JMP absolute
JMP indirect
Bxx relative instructions
JSR absolute with a later RTS
BRK or other IRQ with a later RTI (or RTS if you pull .P off the stack)
Pushing two values to the stack and then RTS/RTI
Hardware reset causes jump through the reset vector

That's it. If you want anything more complicated you need to create it using one or more of the above.

One way to implement a switch statement is to first create a table of pointers to all routines involved in the switch statement. Split them according to the low bytes of the routines and then the high bytes:

switchtab_lo .db >routine1, >routine2, >routine3

switchtab_hi .db <routine1, <routine2, <routine3

(I can never remember if > means low byte or high byte and different assemblers may have different syntax)

and then, assuming the value you want to switch upon is in .X, and that vector is two bytes that don't start at the end of the page (to avoid the JMP indirect bug) and you've made sure it's a valid value:

lda switchtab_lo,X
sta vector
lda switchtab_hi,X
sta vector+1
jmp (vector)

It's tedious to do this each time you need to switch but that's why high level languages were invented.

score 2 · Answer 4 · answered Oct 21 '15 at 06:58

        lda mem
        asl
        sta jump+1
jump    jmp (vector)

;should be page aligned
vector
        !word func1, func2, func3, func4

if the list of vectors is not aligned, on needs to add the index*2 to the whole vector address, slower, but more memory efficient.

other options would be:

         lda mem
         asl
         clc
         adc mem        ;we assume it does not overflow, so carry stays cleared
         sta branch+1   ;mem * 3
branch   bcc *
         jmp func1
         jmp func2
         jmp func3
         jmp ...

Here in the second your example, if `mem` happens to contain value less than 128, (and it should contain even less, since we multiply it by 3), `clc` becomes redundant and could be removed. — lvd, Oct 23 '15 at 17:41

score 1 · Answer 5 · answered Nov 22 '13 at 22:11

The CMOS 6502 (ie, 65c02) also has the JMP(abs,X) addressing mode, so you can take the input in A, shift left 1 bit with ASL A, (because each address in the table takes two locations), then transfer it to X and do the JMP(Addr_Table,X). Much simpler. This is one of many op-code additions made in the CMOS version. (The CMOS version also fixed all the bugs of the NMOS version).

score 0 · Answer 6 · answered Jan 19 '13 at 04:15

0

I don't know how you'd do this on a 6502, but switches are often compiled into jump tables.

answered Jan 19 '13 at 04:15

icktoofay

126,289
21
250
231

Garth Wilson · Answer 7 · 2013-03-04T04:21:13.287

I have an article on using macros to make program structures in 6502 assembly, at http://wilsonminesco.com/StructureMacros/index.html . I've done it for PIC also, and the links are there for the source code for both. Further additions are coming when I finish a project I'm working on.

The OP is a perfect situation for IF...ELSE...END_IF. When more cases are desired, the jump table works well if the numbers are consecutive and you don't have to test for limits to avoid jumping indirect from outside the table and crashing. Otherwise a CASE statement works nicely. http://forum.6502.org/viewtopic.php?f=2&t=2311&start=15 is the second page of such a discussion, and I show there how you could test for individual cases, a range of numbers, or a scattering of numbers, all in the same CASE statement. I don't have RANGE_OF and SET_OF written yet as 6502 assembly macros. Those are two I only have in Forth.

The goal of these macros of course is to get better control of code by making it much more clear what you're doing, and getting rid of the mass of labels and jumps that commonly characterize assembly code. The macros let you keep full control of every speck of code laid down by the assembler, but you don't have to keep looking at the internal details. In most cases there is absolutely zero penalty in program memory taken or in execution speed. You get the performance of assembly with a lot of the benefits of higher-level languages. Code becomes quicker to develop, more bug-free, and easier to maintain, meaning that it's easier to come back later and figure out what you did when you decide to add a feature or change something.

What methods for using control flow are there in 6502?

7 Answers7