Simple arithmetic is performed on accumulators with the ADD, SUB, ADC, and SBC instructions. The destination is always the accumulator and the source a memory operand. These instructions are regular across all addressing modes.
To perform addition on the index registers try the LEA instruction.
adda #20 ; A takes the value of A+20 addb #-30 ; add a signed value to B (which likewise is treated as signed) subd #$1000 ; 16-bits available for ADD and SUB, but not ADC and SBC adcb ,y ; indexed addressing sbca <reduction ; direct paged addressing
Adds a binary memory operand to an accumulator, A, B, or D. Values can be signed twos complement, or unsigned - it's up to the programmer to be consistent in this regard.
For unsigned values test the Carry flag afterwards; it will be set if there was an overflow from bit 7. For signed values an unintentional overflow from bit 6 will set the Overflow flag. The Zero flag and Negative flag are also set as per the result.
After an addition of two valid unsigned Binary Coded Decimal bytes the Decimal Add Adjust instruction adjusts the value of A to produce a correct BCD result. A valid BCD byte, when read as a hexadecimal value, is a valid two-digit decimal. For example $42 (normally 66) is actually decimal 42 if we chose it to be a BCD value; and $39+$13=$4C, but is transformed to $52 after DAA.
How does it work? For the 8-bit ADD instruction only, the Half-carry flag is set in the result of a carry from bit 3 to bit 4. This is used together with the Carry as part of an intricate adjustment based on the values of each nybble.
What's the point of BCD? In the early days of calculators the conversion from decimal to binary and back again was far more complex than any arithmetic they were likely to perform. Hence this easy to read and display internal format. Nowadays it is pretty well obsolete.
Adds a memory operand, together with the Carry to an 8-bit accumulator, A, or B. There is no 16-bit version of this instruction. Multi-byte arithmetic can be performed by looping using ADC to add bytes, including the carry from the previous addition, starting with the least significant byte.
Subtracts a binary memory operand from an accumulator, A, B, or D. Values can be signed twos complement, or unsigned - it's up to the programmer to be consistent in this regard. Flags are set and tested as per ADD.
Subtracts a binary memory operand, together with the Carry (sometimes called the Borrow in this context) from an 8-bit accumulator, A, or B. There is no 16-bit version of this instruction.
When the Carry flag is clear this is just like SUB. When the Carry is set a value of 1 is subtracted first, so for example, LDA #10; SBCA #3 loads A with 10-1-3, so A becomes 6. Therefore SBC can be used for multi-precision arithmetic just like ADC.
Convert a list of bytes representing decimal digits ranging from 0 to 9 to equivalent printable ASCII characters.
ldb #numDigits printLoop: lda, x+ adda #$30 ; add ASCII '0' to 0..9 range byte for a printable character jsr printChar decb bne printLoop
Multi-precision binary arithmetic. Add the value addressed by Y to that addressed by X. Values are stored in byte big-endian form, so first the number of bytes in the value has to be added to the index register so we can start the addition with the least significant digit. Any carry caused by an addition is added to the next most significant byte.
ldb #numBytes leax numBytes,x leay numBytes,y andcc #$fe ; clear Carry flag multiByte: lda ,-y adca, -x sta ,x decb ; DEC instruction does not alter the Carry flag bne multiByte
Add a bonus to a score. Both are 8-bit signed; overflow is detected and adjusted for before storing the 16-bit total.
clra ldb score addb bonus bvc standard overflow: bmi corrected ; -$50 + -$32 = $B0 + $CE = $7E+Carry = $FF7E coma ; $50 + $32 = $0082 bra corrected standard: sex ; sign extend B into D, which is A(hi):B(lo) corrected: std total