6502.org

I'm completely noob to 6502 ASM, so please be gentle...

I'm looking through the source code for Atari BASIC and the Atari base ROMs. I find a number of instances of something like or .

Am I correct in thinking these are being used as an analog of the non-existing ?

If so, why do some use ADC and others use SBC? What is the reason to use one or the other?

ADC and SBC both add the carry flag to the sum. So ADC #0 will either leave A as it is, or add 1 to it, and SBC #0 will either subtract 1 or leave A unchanged. Without seeing the code you're looking at, my guess would be that these instructions follow other ADC or SBC instructions, and are used to add an 8 bit value to a 16 bit value, like this: to add 8 bit value to 16 bit result, or to subtract 8 bit value to 16 bit result.

The carry flag is used to handle the carry between individual bytes of a larger addition or subtraction. ADC and SBC always use the carry flag: there is no ADD or SUB instruction. So it's normal to start an addition with either CLC (for addition) or SEC (for subtraction) to say that there is no carry into the lowest byte.

The reason that you start with C=1 for subtraction is that it's actually an addition in disguise: rather than implementing another circuit to do the subtraction directly, it uses the addition circuit. To subtract, negate the second operand and then add it. To negate in two's complement you invert every bit and then add one. And rather than having more circuitry to add one, you do that by starting a subtraction with the carry flag set.

If CPA is meant to be "compare A", in line with CPX and CPY, then it does exist: it's called CMP.

Allow me to offer a very belated welcome here, Maury!

Of course, it is shorter and faster to optionally increment upper bytes instead of `lda/adc#0/sta` chaining on each:
While the initial bcc can be done for subtraction, you can't easily test a `dec num` for underflow to $FF like you can check `inc num` with beq/bne, so you can only do one upper byte decrement this way.

However, it must also be mentioned that the examples you were looking at might not technically be doing upper-byte math, but could be changing values based on flags that ended up in the carry bit.

This is all good stuff!

BTW, the background here is for some reason I got interested in whether or not a TZA/TZX/TZY (transfer zero to...) would be useful. In Atari BASIC that would remove 132 #0's, about 1.5% of the total code. I expected to see lots of these, and when paging through them I was surprised to find the ADCs.

John, you mentioned this might be in a 16-bit adder, which may be the case but I can't really tell. It's in some code that searches a table of strings for a given entry, and I suppose that maybe it's calculating an address? But I can't seem to find the code where it does anything with the LSB, but that's entirely possible that it's just my noob.

I wish I could find the code in text form on the 'net, every place I find it is in a ZIP.

It would be a lot easier to help if you could post the code you're looking at.

I found a binary of the Atari 400 BASIC cartridge at https://www.atarimania.com/utility-atar ... 13284.html and disassembled that (attached). It's in CART format, which I know nothing about - I just removed the first 16 bytes and hoped that would work.

I can only see four occurrences of ADC #$00 in there, and they all follow the pattern of adding an 8 bit number to a 16 bit number. For example, at $A490 we have This takes the 8 bit number in Y, adds it to the contents of $95, and puts the result back in Y. It then adds 0 (and carry) to the contents of $96, leaving the result in A. Later code (at $A468) stores this result back in $95/$96.