Thought ROL/ROR would do this...

I have a byte I want to cycle through, where the bits should be shifted with 'wrapping' - like so:

#%00000010 --> #%00000001 --> #%10000000

I thought that ROR / ROL worked this way (and opposite), but it does not seem to in this case. Is my understanding flawed, or is it something deeper in the code giving me the issue? If my understanding is flawed, how do you guys achieve something like this?

Thanks!

ROR and ROL work through a ninth bit, the carry bit, so that you can ROR the least significant bit out of a more significant byte (into the carry) and then ROR that bit into the most significant bit of a less significant byte. Do you want to see a worked example of this?

I see - so directly no, what I was trying wouldn't work directly. It would require a little bit more logic (checking either bit 0 or 7 depending on direction, setting or clearing the carry based on its value so that the ROR/ROL works as described?) Would something like this work? Am I making it too complicated? (assuming I wanted to do this all within one byte)

It's not as complicated as it seems. It's easier for ROL:


And here's ROR:

Yep, that did it! Thanks!

If you're rotating a value in memory (as opposed to A), you can rotate without a branch. This is 10 cycles for zero page dd; add 2 for absolute aaaa, add 2 for indexed dd,X or aaaa,X, and subtract 1 for absolute aaaa,X that does not cross a page (256-byte) boundary.

You can also rotate "without a branch" (i.e. there are 2 branches, but they're arranged so that the execution time constant - 7 cycles) using the accumulator: