Вопрос в стиле "Разрушители мифов"

XOR DX,DX
MOV AX,X
MOV BX,X
MUL BX

Команда mul выполняет умножение целого числа без знака, находящегося в регистре AL (в случае умножения на байт) или АХ (в случае умножения на слово), на операнд-источник (целое число без знака). Размер произведения в два раза больше размера сомножителей.
Для однобайтовых операций один из сомножителей помещается в регистр AL; после выполнения операции произведение записывается в регистр АХ.
Для двухбайтовых операций один из сомножителей помещается в регистр АХ; после выполнения операции произведение записывается в регистры DX:AX (в DX - старшая часть, в АХ - младшая). Предыдущее содержимое регистра DX затирается.
Если содержимое регистра АН после однобайтового умножения или содержимое регистра DX после двухбайтового умножения не равны 0, флаги CF и OF устанавливаются в 1. В противном случае оба флага сбрасываются в 0.
В качестве операнда-сомножителя команды mul можно указывать регистр (кроме сегментного) или ячейку памяти; не допускается умножение на непосредственное значение. Команда воздействует на флаги OF и CF.
 
 
Пример 1
mov AL,5 ;Первый сомножитель 
mov BL,3 ;Второй сомножитель 
mul BL ;AX=000Fh, произведение
 
Пример 2
mov AX,256 ;Первый сомножитель 
mov BX,256 ;Второй сомножитель 
mul BX ;DX=0001h, AX=0000h
;(DX:AX=65536, произведение)
 
Пример 3
;В полях данных
coef db 100 ;Первый сомножитель
datal db 126 ;Второй сомножитель
mov AL,datal ;AL=7Eh=126
mul coef ;AX=3138h=12600,произведение
 
Пример 4
;B полях данных
coef dw 5000 ;Первый сомножитель 
datal dw 1200 ;Второй сомножитель 
mov AX,datal ;AX=4BOh=1200 
mul coef ;DX=005Bh, AX=8D80h 
;Произведение=ВХ:AX= 
;5B8D80h=6000000

; Требуется директива .286C или выше.
outfloat proc   near
        push    ax
        push    cx
        push    dx
; Формируем кадр стэка, чтобы хранить в нём десятку
; и ещё какую-нибудь цифру.
        push    bp
        mov     bp, sp
        push    10
        push    0
; Проверяем число на знак, и если оно отрицательное,
        ftst
        fstsw   ax
        sahf
        jnc     @of1
; то выводим минус
        mov     ah, 02h
        mov     dl, '-'
        int     21h
; и оставляем модуль числа.
        fchs
; Пояснение далее пойдёт на примере.   ; ST(0) ST(1) ST(2) ST(3) ...
; Отделим целую часть от дробной.      ; 73.25 ... что-то не наше
@of1:   fld1                           ;  1    73.25 ...
        fld     st(1)                  ; 73.25  1    73.25 ...
; Остаток от деления на единицу даст дробную часть.
        fprem                          ;  0.25  1    73.25 ...
; Если вычесть её из исходного числа, получится целая часть.
        fsub    st(2), st              ;  0.25  1    73    ...
        fxch    st(2)                  ; 73     1     0.25 ...
; Сначала поработаем с целой частью. Считать количество цифр будем в CX.
        xor     cx, cx
; Поделим целую часть на десять,
@of2:   fidiv   word ptr [bp - 2]      ;  7.3   1     0.25 ...
        fxch    st(1)                  ;  1     7.3   0.25 ...
        fld     st(1)                  ;  7.3   1     7.3   0.25 ...
; отделим дробную часть - очередную справа цифру целой части исходного числа,-
        fprem                          ;  0.3   1     7.3   0.25 ...
; от чатсного оставим только целую часть
        fsub    st(2), st              ;  0.3   1     7     0.25 ...
; и сохраним цифру
        fimul   word ptr [bp - 2]      ;  3     1     7     0.25 ...
        fistp   word ptr [bp - 4]      ;  1     7     0.25 ...
        inc     cx
; в стэке.
        push    word ptr [bp - 4]
        fxch    st(1)                  ;  7     1     0.25 ...
; Так будем повторять, пока от целой части не останется ноль.
        ftst
        fstsw   ax
        sahf
        jnz     short @of2
; Теперь выведем её.
        mov     ah, 02h
@of3:   pop     dx
; Вытаскиваем очередную цифру, переводим её в символ и выводим.
        add     dl, 30h
        int     21h
; И так, пока не выведем все цифры.
        loop    @of3                   ;  0     1     0.25 ...
; Итак, теперь возьмёмся за дробную часть, для начала проверив её существование.
        fstp    st(0)                  ;  1     0.25 ...
        fxch    st(1)                  ;  0.25  1    ...
        ftst
        fstsw   ax
        sahf
        jz      short @of5
; Если она всё-таки ненулевая, выведем точку
        mov     ah, 02h
        mov     dl, '.'
        int     21h
; и не более шести цифр дробной части.
        mov     cx, 6
; Помножим дрообную часть на десять,
@of4:   fimul   word ptr [bp - 2]      ;  2.5   1    ...
        fxch    st(1)                  ;  1     2.5  ...
        fld     st(1)                  ;  2.5   1     2.5  ...
; отделим целую часть - очередную слева цифру дробной части исходного числа,-
        fprem                          ;  0.5   1     2.5  ...
; оставим от произведения лишь дробную часть,
        fsub    st(2), st              ;  0.5   1     2    ...
        fxch    st(2)                  ;  2     1     0.5  ...
; сохраним полученную цифру во временной ячейке
        fistp   word ptr [bp - 4]      ;  1     0.5  ...
; и сразу выведем.
        mov     ah, 02h
        mov     dl, [bp - 4]
        add     dl, 30h
        int     21h
; Теперь, если остаток дробной части ненулевой
        fxch    st(1)                  ;  0.5   1    ...
        ftst
        fstsw   ax
        sahf
; и мы вывели менее шести цифр, продолжим.
        loopnz  @of4                   ;  0     1    ...
; Итак, число выведено. Осталось убрать мусор из стэка.
@of5:   fstp    st(0)                  ;  1     ...
        fstp    st(0)                  ;  ...
; Точнее, стэков.
        leave
        pop     dx
        pop     cx
        pop     ax
        ret
outfloat endp

value_s2f   dw  0           ;переменая для функции преобразования строки в число
 
 
;+==============================================+
;|          ПЕРЕВОД ИЗ STRING В FLOAT           |
;+==============================================+
;| SI - указатель на строку                    |
;+----------------------------------------------+
;| ST(0) - преобрезованное число                |
;| cf=1 если в строке ошибка           |
;+==============================================+
STRTOFLOAT  PROC
    jmp     @STARTCONVERSATION_S2F  ; стартуем в рабочую область
@STARTCONVERSATION_S2F:
    pusha
    mov     value_s2f, 0            ; обнуляем локальную переменную
    xor     bx, bx              ; очищаем указатель позиции
    cmp byte ptr [si], '-'      ; проверяем на отрицательность
    jne     @POSITIVE_S2F       ; число не отрицательное
    inc     bx                  ; число отрицательное, увеличиваем позицию
@POSITIVE_S2F:
    mov     value_s2f, 10       ; загружаем число в переменную
    fild        value_s2f           ; загружаем в стэк число 10
    fldz                            ; загружаем в стэк число 0
@REPEAT_BEFORE:
    mov     al, byte ptr si[bx]     ; получаем символ
    cmp al, byte ptr '.'            ; проверяем точка ли это
    je      @ISPOINTBEFORE  ; точка - идем дальше
    cmp al, byte ptr 13         ; проверяем конец ли строкиа
    je      @ENDASINT       ; уже конец и хватит искать дроби
    cmp al, '0'             ; если текущий символ не цифра
    jc  @END_S2F_ERR            ; то выход с ошибкой
    cmp     al,'9'
    ja  @END_S2F_ERR
    sub     al, 30h             ; делаем из CHAR - INT
    mov     byte ptr value_s2f, al  ; копируем в память
    fiadd   value_s2f           ; складываем из тем, что есть в стэке
    fmul    st(0), st(1)            ; умножаем на 10
    inc     bx                  ; увеличиваем указатель
    jmp     @REPEAT_BEFORE  ; повторяем
@ISPOINTBEFORE:
    inc     bx                  ; увеличиваем указатель
    fdiv        st(0), st(1)            ; делим число на 10, т.к. оно уже больше
    fxch        st(1)               ; меняем местами регистры
    mov     al, byte ptr 13         ; ищем символ конца строки
@FINDNEXT:
    cmp si[bx], al              ; ищем конец строки
    je      @FINDEND            ; нешел конец строки
    inc     bx                  ; получаем следующий адрес символа
    jmp     @FINDNEXT           ; не нашел, еще ищем
@FINDEND:
    dec     bx                  ; переходим на предыдущий символ
    fldz                            ; загружаем в стэк число 0
@REPEAT_AFTER:
    mov     ax, word ptr si[bx]     ; получаем символ
    cmp al, byte ptr '.'            ; проверяем точка ли это
    je      @WASPOINTAFTER  ; точка - идем дальше
    cmp al, '0'         ; если текущий символ не цифра
    jc  @END_S2F_ERR            ; то выход с ошибкой
    cmp     al,'9'
    ja  @END_S2F_ERR
    sub     al, 30h             ; делаем из CHAR - INT
    mov     byte ptr value_s2f, al  ; копируем в память
    fiadd   value_s2f           ; складываем из тем, что есть в стэке
    fdiv        st(0), st(1)            ; делим на 10
    dec     bx                  ; декрементируем указатель
    loop    @REPEAT_AFTER   ; повторяем
@WASPOINTAFTER:
    fxch        st(1)               ; меняем число 10 и остаток местами
    fxch        st(2)               ; меняем целое и 10 местами
    faddp   st(1)               ; складываем число до и после запятой
    fxch        st(1)               ; меняем местами результат и 10
    fistp       value_s2f           ; извлекаем из стэка 10
    jmp     @FULLEND            ; полный конец процедуры
@ENDASINT:
    fdiv        st(0), st(1)            ; делим число на 10, т.к. оно уже больше
    fxch        st(1)               ; меняем местами регистры
    fistp       value_s2f           ; извлекаем из стэка 10
@FULLEND:
    cmp byte ptr [si], '-'      ; проверяем на отрицательность
    jne     @END_S2F            ; число не отрицательное
    fchs                            ; число отрицательное, меняем знак
@END_S2F:
    popa                        ; выгружаем все регистры
    clc                     ;ошибки нет
    ret                         ; возврат из процедуры
 
@END_S2F_ERR:
    popa                        ; выгружаем все регистры
    fistp value_s2f             ;очищаем st0
    stc                 ;ошибка
    ret                         ; возврат из процедуры
STRTOFLOAT  ENDP

.686p
.model flat
includelib user32.lib
include windows.inc
extern _imp__MessageBoxA@16:dword
.code
start:  fld x
    call outfloat
    push 0
    push 0
    push offset String
    push 0
    call _imp__MessageBoxA@16
    retn
outfloat proc
    mov edi,offset String
    fldz
    fcomip st,st(1);Проверяем число на знак, и если оно отрицательное,
        jc @of1
    mov al,'-'; то выводим минус 
    stosb
        fchs; и оставляем модуль числа.
@of1:   fld st
    fstcw [control]
    or [control],110000000000b
    fldcw [control];делаем округление к нулю
    frndint                 
    fsub st(1),st           
    fbstp [bcdstr]           
    mov ecx,9    ;в десятом байте информация о знаке числа
b2:     cmp byte ptr [ecx-1+bcdstr],0            
    loopz b2;пропускаем незначащие (нулевые) разряды слева
    mov al,byte ptr [ecx+bcdstr];загружаем первую значащую пару разрядов
        cmp al,9  ;если в старшей тетраде 0 - пропустить старшую тетраду
    ja b4
    add al,30h  ;младшую тетраду переводим в ASCII
    stosb   
        jecxz b1
b4:     movzx ax,byte ptr [ecx+bcdstr];распаковываем остальные разряды числа
    ror ax,4    ;выделяем старшую и младшую тетрады
    shr ah,4
    add ax,3030h;переводим в ASCII-код
    stosw; и сразу выведем
    loop b4
b1: fldz; теперь возьмёмся за дробную часть, для начала проверив её существование.
        fcomip st,st(1)
        jz @of5
    mov al,'.'; Если она всё-таки ненулевая, выведем точку
    stosb
        mov ecx,6
@of4:   push eax
    fimul y; множим дрообную часть на десять
        fld st
        frndint; отделим целую часть
        fsub st(1), st; оставим от произведения лишь дробную часть,
        fistp dword ptr [esp]; сохраним полученную цифру во временной ячейке
    pop eax
        add al,30h
        stosb; и сразу выведем
    fldz
        fcomip st,st(1);если остаток дробной части ненулевой
        loopnz  @of4;если вывели менее шести цифр, продолжим.
@of5:   retn
outfloat endp
.data
String db 50 dup (0)
x dt -70600500043210.92345678
y dd 10
bcdstr dt ?
control dw ?
end start

format PE GUI 4.0
entry start
include 'include\win32ax.inc'
section '' code readable writeable executable import data
library user32,'user32.dll'
import user32,\
       MessageBox,'MessageBoxA'
start: fld    [x]
 call   outfloat
 invoke MessageBox,0,String,0,0
 retn
outfloat:
    mov    edi,String
    ftst
    fstsw  ax
    shr    eax,8
    and    eax,1
    mov    byte[edi],'-'
    add    edi,eax
    fabs
    fld1        ;вычисляем длину целой части числа
    fld   st1
    fyl2x
    fldl2t
    fdivp
    fistp dword[esp-4]
    cmp   dword[esp-4],1
    adc   dword[esp-4],0
    mov   ecx,[esp-4]       ;ecx - длина целой части
    @@:fidiv [y]       ;нормализуем число (приводим к виду 0.xxx)
    loop @b
    mov   ecx,[esp-4]
    @@:fimul  [y]
       fld    st0
       fisttp word[esp-2]      ;сохраняем целую часть (SSE3)
       fisub  word[esp-2]
       mov    al,[esp-2]
       add    al,'0'
       stosb
       ftst
       fstsw  ax
       test   ax,100000000000000b
    loope @b
    mov al,'.'
    stosb
    sub ecx,1
    jc @b
    mov    byte[edi-1],0      ;завершающий ноль
retn
x      dt -3.92345678
y      dw 10
String rb 128