The das instruction is used to adjust the content of the AL register after that register is used to perform the subtraction of two packed BCDs. The CPU uses the following logic:
CF_old = CF IF (al AND 0Fh > 9) or (the Auxilliary Flag is set) al = al-6 CF = CF or CF_old AF set ENDIF IF (al > 99h) or (Carry Flag is set) al = al - 60h CF set ENDIFAlthough this instruction should be used immediately after the subtraction instruction, it could be used later as long as no other intervening instruction would have changed the AF or CF flags (such as a mov instruction).
Example 1: mov al,73h ;packed decimal "73" sub al,45h ;subtract packed decimal "45" daa ;AL = 2Eh -> 28h (with CF clear = 28 packed decimal) AL CF AF ; after subtraction 2Eh clear set ; daa 1st part (al-6) 28h clear set (because al AND 0Fh > 9) ; daa 2nd part (nothing) 28h clear set (al !> 99h && CF clear)
Example 2: mov al,38h ;packed decimal "38" sub al,74h ;subtract packed decimal "74" daa ;AL = 0C4h -> 64h with borrow from next digit AL CF AF ; after subtraction 0C4h set clear ; daa 1st part (nothing) 0C4h set clear (al AND 0Fh !> 9 && AF clear) ; daa 2nd part (al-60h) 64h set clear (because CF set)
Example 3: mov al,47h ;packed decimal "47" sub al,49h ;subtract packed decimal "49" daa ;AL = 0FEh -> 98h with borrow from next digit AL CF AF ; after subtraction 0FEh set set ; daa 1st part (al-6) 0F8h set set (because al AND 0Fh > 9) ; daa 2nd part (al-60h) 98h set set (because CF set)The resulting Carry Flag must always be used with the next subtraction. There should never be any carry from the subtraction of the last packed byte; otherwise, the result would be erroneous. The smaller number must always be subtracted from the larger one and a negative sign inserted with the result if necessary.
The following code is an example of subtracting two large packed BCD numbers in "string" order, (i.e. num1 - num2). It assumes that neither number has leading 0 bytes reflected in its size. Otherwise, a longer number with such leading 0 bytes could actually be smaller than the other with fewer bytes and lead to an erroneous result.
Code is also added to convert the resulting packed BCD result to a null-terminated string without any leading "0" character. The byte count of each source number has been initialized in the data section to save coding instructions (the byte count could be obtained otherwise by several means).
.data answer db 16 dup(0) num1size dd 7 num2size dd 8 num1 db 78h,96h,19h,03h,21h,38h,55h ; 78961903213855 packed num2 db 7h,27h,52h,83h,61h,84h,68h,15h ;727528361846815 packed signbit db ? ;0=positive, !0=negative txtbuf db 32 dup(?) .code start: mov edi,offset num1 mov esi,offset num2 mov ecx,num1size mov edx,num2size mov signbit,0 .if ecx < edx ;result would be negative negative: xchg esi,edi ;use EDI to point to longest number xchg ecx,edx ;use ECX to hold largest count of packed bytes mov signbit,1 .elseif ecx == edx push esi push edi push ecx repz cmpsb ;compare the two numbers pop ecx pop edi pop esi .if ZERO? ;both numbers are equal mov answer,0 mov txtbuf,"0" jmp exit .endif jnc negative ;num2 > num1 .endif add edi,ecx ;must start with least significant digits add esi,edx ; idem mov ebx,offset answer clc ;start with CF clear @@: dec edi dec esi mov al,[edi] sbb al,[esi] das ;decimal adjust subtraction result mov [ebx],al ;store it inc ebx dec ecx dec edx jnz @B ;process all bytes of smallest number pushfd ;keep current flags or ecx,ecx ;is longest number also completed? jz no_more popfd ;retrieve flags @@: dec edi mov al,[edi] sbb al,0 das mov [ebx],al inc ebx dec ecx jnz @B ;process remaining bytes of longest number no_more: mov ecx,ebx ;EBX points to byte following most significant one mov edx,offset answer sub ecx,edx ;ECX = number of packed bytes in answer mov edi,offset txtbuf ; The following is to convert the result to ASCII ; First insert negative sign if necessary .if signbit != 0 mov al,"-" stosb .endif ; Remove any leading packed BCD 0's @@: dec ebx mov al,[ebx] or al,al jnz @F dec ecx ;adjust count of bytes in answer jmp @B ;check next byte ; Then process separately a leading 0 in the most significant byte @@: .if al < 10 ;no high nibble add al,30h stosb jmp nextbyte .endif ; Process the other bytes @@: movzx eax,byte ptr[ebx] ror ax,4 ;shift most significant nibble to least significant ;while least significant transfers to AH ror ah,4 ;do same with AH which contains the least ;significant nibble of AL in the upper 4 bits add ax,3030h ;convert both digits to ASCII stosw ;store both characters ;the more significant of the two having been kept in AL will ;get stored ahead of the less significant one in the string nextbyte: dec ebx dec ecx jnz @B exit: mov [edi],cl ;add string terminating 0 ; The ASCII representation of the packed BCD result is now available as a ; null-terminated string at the txtbuf address.