ADC

From C64-Wiki
Jump to: navigation, search

ADC (short for "ADd with Carry") is the mnemonic for a machine language instruction which adds the byte held in the accumulator with that held in the memory address specified: The state of the carry flag before the addition takes place, is taken as the incoming carry in the addition. After the addition, the carry flag will hold the outgoing carry. Contrary to many other CPUs, the architecture of the 65xx family (of which the 6510 in the Commodore 64 is a member) does not have separate instructions for addition with or without taking the carry flag as the incoming carry. Therefore the programmer must make sure that carry is clear prior to an addition for which there is no incoming carry – this is usually accomplished with the CLC instruction, for example:

LDA Num1    Read the first byte value from Num1
CLC         No incoming carry; make sure carry is clear
ADC Num2    Perform the addition
STA Result  Store result in Result

This example takes the byte stored in a memory address labelled Num1, and adds it with the contents of a memory address labelled Num2, and stores the result in a third place with the label Result.

In a few special cases (such as immediately following a BCS), the carry is always clear in any situation where the CPU reaches the ADC instruction; this allows for leaving out the CLC, saving 1 byte and 2 machine cycles execution time.

The inclusion of the incoming carry provides a simple means to add binary integers of arbitrary length, "spread" across two or more bytes: Add the least significant byte pair first with the carry cleared, then add increasingly significant bytes without modifying the carry. This will let the outgoing carry from one addition "travel" from one addition to the next. The following example assumes that Num1 and Num2 mark the first of two series of bytes, of increasing significance, each holding a "dozens-of-bits" integer, and stores the result as a series of byte in the same order, beginning at label Result:

LDA Num1     Add the least
CLC          significant pair
ADC Num2     with the carry
STA Result   cleared ...

LDA Num1+1   Add next byte
ADC Num2+1   pair without
STA Result+1 clearing carry

LDA Num1+2   and the next
ADC Num2+2   pair...
STA Result+2

... etc.

ADC handles both signed and unsigned integers: Both examples above will yield correct results for any pair of integer where both the integers and the resulting sum are within the limits imposed by the number of bits involved: The single-byte addition example works for unsigned integers in the range 0–255/$0–FF as well as signed integers in the −128–+127/$−80–+7F range. For 16-bit (2 bytes) unsigned integers, the limits are 0–65535/$0–FFFF; for signed 16-bit quantities, it's −32768–+32767/$−8000–+7FFF, etc.

Addressing modes[edit]

Opcode Addressing
mode
Assembler
format
Length
in bytes
Number of
cycles
Dec Hex
105 69 Immediate ADC #nn 2 2
109 6D Absolute ADC nnnn 3 4
125 7D Absolute,X ADC nnnn,X 3 4*
121 79 Absolute,Y ADC nnnn,Y 3 4*
101 65 Zeropage ADC nn 2 3
117 75 Zeropage,X ADC nn,X 2 4*
97 61 Indexed-indirect ADC (nn,X) 2 6
113 71 Indirect-indexed ADC (nn),Y 2 5*

ADC supports eight different addressing modes, as shown in the table at right. In the assembler formats listed, nn represents a single-byte (8-bit) figure, and nnnn is a two-byte (16-bit) address.
With some addressing forms (marked with an asterisk, *, in the "Number of cycles" column) the execution time for ADC depends on the circumstances: In cases where the indexing requires the CPU to "reach across" a page boundary from the base address, the execution time is 1 cycle longer than listed here.

CPU flags[edit]

ADC affects 4 of the CPU's status flags:

  • The negative status flag is set if the result is negative, i.e. has it's most significant bit set.
  • The overflow status flag is set if the operation results in an overflow.
  • The zero flag is set if the result is zero, or cleared if it is non-zero.
  • The carry flag is set if the addition resulted in an outgoing carry.