I've been toying around with the 6-instruction, 8-byte, 12-cycle nybble swap code found at http://6502.org/source/general/SWN.html and I've been intrigued by the genius of this technique. I was curious if there were any other uses for this or a similar sort of pattern. Like what if you ADC different values, or used SBC instead, or shifted to the right instead of to the left. So far, I almost came up empty handed.

I did find that using SBC #$7F gives the exact same result as the ADC #$80, even the resulting overflow and carry flags are exactly the same. In addition, I found that the overflow always matches bit 0 of the result, and the carry is always the opposite. So if the result from the swap is even, the overflow will be 0 and carry will be 1. If odd, then overflow is 1 and carry is 0. I don't think this info would be of any use to anyone, but I though it was interesting enough and worth mentioning.

I have observe the flag results by making a loop, running every possible value through it, and saving both flag results for inspection. Here's my code if anyone wants to see it. The offset from location $6000 represents the resulting values from the swaps. The values of those locations represent the 2 flags: overflow (high nibble) and carry (low nibble).

Assembled with: https://www.masswerk.at/6502/assembler.html
Code tested in: AppleWin

You can paste this into your emulator. Warning: Screen will scroll!
300:A2 00 8A 0A 69 80 2A 0A 69 80 2A A8 70 03 A9 00 2C A9 08 2A 99 00 60 E8 D0 E8 60 N 300G N 6000.60FF

ADC,ADC - 304:69 80 N 308:69 80 N 300G N 6000.60FF
SBC,SBC - 304:E9 7F N 308:E9 7F N 300G N 6000.60FF
ADC,SBC - 304:69 80 N 308:E9 7F N 300G N 6000.60FF
SBC,ADC - 304:E9 7F N 308:69 80 N 300G N 6000.60FF

I think ADC and SBC are basically the same inside the CPU, it's just that SBC inverts the second operand before adding it on. So subtracting $7F is the same as adding $80. This is why the carry flag behaviour feels backwards.

The nybble rotate code is clever but not magic. The idea is to rotate four times but without including the carry flag in the operation, unlike the 6502's normal rotate instruction. The first line shifts one place with the high bit going into the carry flag. To complete the first shift we just want to get that value out of the carry flag into the low bit. ADC #0 would do that, and you could repeat those two instructions four times to get the desired result. It only works with left shifts because ADC can only move the carry flag into the bottom bit.

The clever shortcut in that code though is that instead of adding zero to extract the carry flag into the bottom bit, it adds $80 which also inverts the top bit, causing a new carry if it was set originally. This effectively moves that top bit into the carry flag, which allows a follow-up ROL to rotate that value out of the carry flag into the bottom bit more efficiently.

So that pair of instructions achieves a two-bit ROL skipping over the carry flag, and doing it twice achieves the desired four-bit rotate.

It's a very neat sequence.

Changing the constants would allow you to add arbitrary amounts to the result, but not much more than that.

This website has lots of crafty little ways of doing common operations using combinations of bit shifting, boolean operations and arithmetic:

https://graphics.stanford.edu/~seander/bithacks.html

(welcome, EriknocTDW!)

@gfoot
Ah yes. I've been pondering that over the weekend. For some reason, my brain kept focusing on the overflow flag, that somehow it played a roll. The overflow is affected by ADC and SBC, but not vice versa. So I'm not sure how I got my brain wires crossed, but I get it now and it's exactly like you said. Thank you.

@kernelthread
Thank you.

@BigEd
And thank you to you too.

8-bit rotate left:
CMP #&80 ; a abcdefgh
ROL A ; a bcdefgha

8-bit rotate left:
ASL A ; a abcdefg0
ADC #0 ; 0 bcdefgha

rotate right arithmetic (sign remains same):
CMP #&80 ; a abcdefgh
ROR A ; h aabcdefg

_________________
--
JGH - http://mdfs.net

It might not feel so backwards if you remember that when you're doing a subtraction it does not turn into a borrow flag, as it does on the 6800, but remains a carry flag, which you can think of as the opposite of a borrow flag. (I think I have that right; I've not been programming in 6502 assembler for while.)

_________________
Curt J. Sampson - github.com/0cjs

Other than the potential for initial confusion, I think the /carry = borrow idea is brilliant in its utter simplicity.

_________________
Got a kilobyte lying fallow in your 65xx's memory map? Sprinkle some VTL02C on it and see how it grows on you!

Mike B. (about me) (learning how to github)

@jgharston


I didn't think about CMP#$80/ROL. That's smart too, using 4 cycles.
Although the ASL/ADC#$80/ROL sequence effectively rotates 2 bits, using only 6 cycles.


I believe you mean: ASL A ; a bcdefgh0
But, yeah. This one's also good for rotating 1 bit at a time using 4 cycles.


What's a good use case for this one?

It's just a signed divide by two, so good if you need to shift something that might be negative.

In effect, it's ASR (Arithmetic Shift Right).