Hi,

I've been reading up on the CMP instruction (CMP and SBC are the only two that are giving me any grief) and I found some really good information on this web site, and I was doing well until a question poped into my head.

It says on tutorials/compare_beyond.html that "both [CMP and SBC] affect the N, Z, and C flags in exactly the same way".

Given this information I took the source code for my emulated SBC instruction and poped into my CMP instruction (ignoring the carry, not modifying the registers, and ignoring the BCD handling) and the results are NOT the same. Obviously something is wrong.

However, if I take the table (showing how the flags are set) listed on tutorials/compare_instructions.html and implement that in my CMP instruction and not do any subtracting etc. the instruction works perfect.

Am I missing something?

Any clarification on these two instructions would make me so happy...

Thanks,

Andrew

Computers compare numbers by subtracting one value from the other and looking at result. Thats why CMP and SBC set the flags the same way.

For example if you subtract to equal values the result will be zero and would set the 6502's zero flag. If the values are unequal the result would be non zero. If you subtract a big unsigned value from a small one you generate a 'borrow' which clears the carry flag. Subtracting a small unsigned value from a larger (or equal sized) one does not generate a 'borrow' so the carry would be set.

(I won't complicate this discussion with signed values and overflow -- Look them up when you understand unsigned comparison)

There are a couple of key differences between CMP/CPX/CPY and SBC to remember:

1. CMP/CPX/CPY is not affected by the value of the carry flag at point of execution, SBC is. (CMP/CPX/CPY acts as if there is an implied SEC before the subtraction).

2. CMP/CPX/CPY does not keep the result of the subtraction, it is used only to set the flags then it is discarded, SBC does.

What the document is saying is that settings of the flags after a code sequence like this...

... will be exactly the same as after ...

... but the value of accumlator is different (i.e. in the first case A = VAL1-VAL2 and in the second A = VAL1)

_________________
Andrew Jacobs
6502 & PIC Stuff - http://www.obelisk.me.uk/
Cross-Platform 6502/65C02/65816 Macro Assembler - http://www.obelisk.me.uk/dev65/
Open Source Projects - https://github.com/andrew-jacobs

Not quite. It says that CMP and the sequence SEC SBC affect the N, Z, and C flags in the same way. The D flag is assumed to be zero, so really the SBC sequence is CLD SEC SBC. Anyway, you don't have to take my word for it. Here is a program that demonstrates that it is true. Conveniently, it stops at the first counterexample. It takes about 4 seconds (assuming it passes) at 1 MHz. If it doesn't work on the emulator, then the emulator has a bug.



I really didn't intend for the tutorial to be an introduction to the CMP instruction. It's more of a compilation of different comparison techniques and optimization tips. The title is "Beyond 8-bit unsigned comparisons" and one section is named "Review of compare instructions', so a familarity with the CMP instruction was assumed.



I can only guess where the problem might be, but when you "ignore" BCD handling, you must subtract as though the D flag is ZERO, and when you "ignore" the carry you must subtract as though it were ONE.

Also, CMP does not affect the V flag, unlike SBC.

Well, I run the code of "dclxvi" and got as result "ERROR=0" confirming (as expected) that:


"CMP and SBC affect the N, Z, and C flags in exactly the same way"

as expected.