ADC works like ADD but also adds the carry flag: the result is destination + source + CF, where CF is 0 or 1. It takes the same operand forms as ADD (byte or word, no memory-to-memory, no segment registers) and sets all six arithmetic flags the same way.

Multi-word addition

The 8086 adds at most 16 bits at a time. A 32-bit number is kept as two words, low word first in memory, and is often held in the pair DX:AX (DX the high word). Add the low words with ADD; any carry out of them lands in CF. Then add the high words with ADC, which picks that carry up. For 48 or 64 bits, keep chaining ADC for each further word.

MOV     AX, [NUM1]             ; low word
MOV     DX, [NUM1+2]           ; high word
ADD     AX, [NUM2]             ; FFFFh + 0001h = 0000h, CF = 1
ADC     DX, [NUM2+2]           ; 1 + 3 + carry = 5
MOV     AL, DL                 ; prints 5 (4 without the carry)
ADD     AL, '0'                ; digit -> character
MOV     DL, AL
MOV     AH, 02h                ; DOS: print DL
INT     21h
 
NUM1    DW      0FFFFh, 0001h  ; 0001FFFFh, low word first
NUM2    DW      0001h, 0003h   ; 00030001h

Nothing between the ADD and the ADC may change CF. MOV and LEA leave the flags alone, while another ADD, SUB, CMP, NEG or a shift would overwrite CF. INC and DEC keep CF, which is why a loop over the words of a long number can step its pointers with INC.

Other uses

ADC AX, 0 adds just the carry, for example to count how many additions overflowed or to finish a 32-bit sum where the second number is only 16 bits wide. After a shift or a rotate that moved a bit into CF, ADC can collect that bit into a counter.

ADD     AX, BX  ; DX:AX = DX:AX + BX
ADC     DX, 0   ; carry into the high word

Pitfall

Clear the carry yourself (CLC) if the first step of a loop uses ADC instead of ADD; otherwise a stale CF from earlier code is added in.