Untitled

; ------------------------------------------------------------------------------------- ;
;   Лабораторная работа №1 по курсу Программирование на языке ассемблера                ;
;   Вариант №1.1                                                                       ;
;   Выполнил студент Мухаматулин Максим                                                 ;
;                                                                                       ;
;   Исходный модуль LabAssignment.asm                                                 ;
;   Содержит функции на языке ассемблера, разработанные в соответствии с заданием        ;
; ------------------------------------------------------------------------------------- ;
;   Задание: Реализовать прямое и обратное преобразования Фурье
;   Формат данных сигнала: __int8
;   Формат данных спектра: float
;   Размер (количество отсчетов) сигнала и спектра: 8
;   Способ реализации: DFT 4x4 + 1 бабочка
;   Отсчеты спектра являются комплексными числами. Причем действительные части хранятся
;   в первой половине массива, а мнимые - во второй
.DATA
two real8 2.0
.CODE
; ------------------------------------------------------------------------------------- ;
; void CalculateSpectrum(spectrum_type* Spectrum, signal_type* Signal)                  ;
;   Прямое преобразование Фурье. Вычисляет спектр Spectrum по сигналу Signal           ;
;   Типы данных spectrum_type и signal_type, а так же разимер сигнала                    ;
;   определяются в файле Tuning.h                                                     ;
; ------------------------------------------------------------------------------------- ;
; e - четная часть сигнала, o - нечетная часть сигнала
;
;  Signal = [a0, a1, a2, a3, a4, a5, a6, a7]
;
;          +---------------+   +-----+   +--+           +----------------------------+   +------------------+   +-------------+
;          |(a0+a4)+(a2+a6)|   |t1+t2|   |e1|           |        a1+a7+a3+a5         |   |       t3+t4      |   |      e5     |
;          |     a0-a4     |   |  k1 |   |e2|           | sqrt(2)/2*((a1+a7)-(a3+a5))|   | sqrt(2)/2*(t3-t4)|   | sqrt(2)/2*e4|
;          |(a0+a4)-(a2+a6)|   |t1-t2|   |e3|           |             0              |   |         0        |   |      0      |
;  Re(e) = |     a0-a4     | = |  k1 | = |e2|   Re(o) = |-sqrt(2)/2*((a1+a7)-(a3+a5))| = |-sqrt(2)/2*(t3-t4)| = |-sqrt(2)/2*e4|
;          |(a0+a4)+(a2+a6)|   |t1+t2|   |e1|           |       -a1-a7-a3-a5         |   |      -t3-t4      |   |     -e5     |
;          |     a0-a4     |   |  k1 |   |e2|           |-sqrt(2)/2*((a1+a7)-(a3+a5))|   |-sqrt(2)/2*(t3-t4)|   |-sqrt(2)/2*e4|
;          |(a0+a4)-(a2+a6)|   |t1-t2|   |e3|           |             0              |   |         0        |   |       0     |
;          |     a0-a4     |   |  k1 |   |e2|           | sqrt(2)/2*((a1+a7)-(a3+a5))|   | sqrt(2)/2*(t3-t4)|   | sqrt(2)/2*e4|
;          +---------------+   +-----+   +--+           +----------------------------+   +------------------+   +-------------+
;
;          +-------+    +---+    +---+           +------------------------------+   +------------------+   +-------------+
;          |   0   |    | 0 |    | 0 |           |               0              |   |         0        |   |      0      |
;          |-a2+a6 |    |-k2|    |-o3|           | sqrt(2)/2*((-a1+a7)+(-a3+a5))|   | sqrt(2)/2*(k3+k4)|   | sqrt(2)/2*o1|
;          |   0   |    | 0 |    | 0 |           |       (-a1+a7)-(-a3+a5)      |   |       k3-k4      |   |      o2     |
;  Im(e) = | a2-a6 | =  | k2| =  | o3|   Im(o) = | sqrt(2)/2*((-a1+a7)+(-a3+a5))| = | sqrt(2)/2*(k3+k4)| = | sqrt(2)/2*o1|
;          |   0   |    | 0 |    | 0 |           |               0              |   |         0        |   |      0      |
;          |-a2+a6 |    |-k2|    |-o3|           |-sqrt(2)/2*((-a1+a7)+(-a3+a5))|   |-sqrt(2)/2*(k3+k4)|   |-sqrt(2)/2*o1|
;          |   0   |    | 0 |    | 0 |           |      -(-a1+a7)+(-a3+a5)      |   |      -k3+k4      |   |     -o2     |
;          | a2-a6 |    | k2|    | o3|           |-sqrt(2)/2*((-a1+a7)+(-a3+a5))|   |-sqrt(2)/2*(k3+k4)|   |-sqrt(2)/2*o1|
;          +-------+    +---+    +---+           +------------------------------+   +------------------+   +-------------+
;
;                     +-----------------+   +---+                      +------------------+   +-----+
;                     |     e1 + e5     |   |re1|                      |         0        |   |  0  |
;                     |e2 + sqrt(2)/2*e4|   |re2|                      |-o3 + sqrt(2)/2*o1|   | ro2 |
;                     |       e3        |   |re3|                      |        o2        |   | ro3 |
;  Re = Re(e)+Re(o) = |e2 - sqrt(2)/2*e4| = |re4|   Im = Im(e)+Im(o) = | o3 + sqrt(2)/2*o1| = | ro4 |
;                     |     e1 - e5     |   |re5|                      |         0        |   |  0  |
;                     |e2 - sqrt(2)/2*e4|   |re4|                      |-o3 - sqrt(2)/2*o1|   |-ro4 |
;                     |       e3        |   |re3|                      |       -o2        |   |-ro3 |
;                     |e2 + sqrt(2)/2*e4|   |re1|                      | o3 - sqrt(2)/2*o1|   |-ro2 |
;                     +-----------------+   +---+                      +------------------+   +-----+
;
CalculateSpectrum PROC              ; [RCX] - Spectrum
                                    ; [RDX] - Signal
    mov al, [rdx+4]                 ; a4
    mov r8b, [rdx+0]                ; a0

    movsx ax, al                    ; a4 (расширенный до int16)
    movsx r8w, r8b                  ; a0 (сразу было нельзя, ограничение )
                                    ; Регистры: ax:a4, r8w:a0

    mov r9w, r8w                    ; a0
    sub r9w, ax                     ; a0-a4=k1=e2
    add r8w, ax                     ; a0+a4=t1
                                    ; Регистры: ax:a4, r8w:t1, r9w:k1

    mov al, [rdx+6]                 ; a6
    mov r10b, [rdx+2]               ; a2
    movsx ax, al                    ; a6 (расширяем)
    movsx r10w, r10b                ; a2
                                    ; Регистры: ax:a6, r8w:t1, r9w:k1, r10w:a2

    mov r11w, r10w                  ; a2
    sub r11w, ax                    ; a2-a6=k2=o3
    add r10w, ax                    ; a2+a6=t2
                                    ; Регистры: ax:a6, r8w:t1, r9w:k1(e2), r10w:t2, r11w:k2(o3)

    mov ax, r8w                     ; t1
    sub r8w, r10w                   ; t1-t2=e3
    add r10w, ax                    ; t1+t2=e1
                                    ; Регистры: ax:t1, r8w:e3, r9w:e2, r10w:e1, r11w:o3

    sub rsp, 2*7                    ; Бронируем 7 мест для элементов длины word
    mov [rsp+2*6], r9w              ; e2
    mov [rsp+2*5], r11w             ; o3
    mov [rsp+2*4], r10w             ; e1
    mov [rsp+2*3], r8w              ; e3
                                    ; Стек(7): *, *, *, e3, e1, o3, e2

    mov al, [rdx+1]                 ; a1
    mov r8b, [rdx+7]                ; a7
    movsx ax, al                    ; a1 (расширенный до int16)
    movsx r8w, r8b                  ; a7
                                    ; Регистры: ax:a1, r8w:a7, r9w:e2, r10w:e1, r11w:o3

    mov r9w, r8w                    ; a7
    sub r9w, ax                     ; a7-a1=k3
    add r8w, ax                     ; a1+a7=t3
                                    ; Регистры: ax:a1, r8w:t3, r9w:k3, r10w:e1, r11w:o3

    mov al, [rdx+3]                 ; a3
    mov r10b, [rdx+5]               ; a5
    movsx ax, al                    ; a3 (расширяем)
    movsx r10w, r10b                ; a5
                                    ; Регистры: ax:a3, r8w:t3, r9w:k3, r10w:a5, r11w:o3

    mov r11w, r10w                  ; a5
    sub r11w, ax                    ; a5-a3=k4
    add r10w, ax                    ; a3+a5=t4
                                    ; Регистры: ax:a3, r8w:t3, r9w:k3, r10w:t4, r11w:k4

    mov ax, r8w                     ; t3
    sub r8w, r10w                   ; t3-t4=e4
    add r10w, ax                    ; t3+t4=e5
                                    ; Регистры: ax:t3, r8w:e4, r9w:k3, r10w:e5, r11w:k4

    mov ax, r9w                     ; k3
    sub r9w, r11w                   ; k3-k4=o2
    add r11w, ax                    ; k3+k4=o1
                                    ; Регистры: ax:k3, r8w:e4, r9w:o2, r10w:e5, r11w:o1

    mov [rsp+2*2], r9w              ; o2=ro3
                                    ; Стек(7): *, *, o2(ro3), e3, e1, o3, e2

    mov r9w, [rsp+2*4]              ; e1
    mov ax, r9w                     ; e1
    sub r9w, r10w                   ; e1-e5=re5
    add r10w, ax                    ; e1+e5=re1
                                    ; Регистры: ax:e1, r8w:e4, r9w:re5, r10w:re1, r11w:o1
    mov [rsp+2*1], r10w             ; re1
    mov [rsp+2*0], r9w              ; re5
                                    ; Стек(7): re5, re1, o2(ro3), e3(re3), e1, o3, e2
    finit

    fld two                         ; Вычисление sqrt(2)/2
    fsqrt
    fdiv two
                                    ; ST: sqrt(2)/2

    fild word ptr [rsp+2*0]         ; Загрузка re5 как int16
    fstp dword ptr [rcx+4*4]        ; Сохранение re5 как float

    fild word ptr [rsp+2*1]         ; Загрузка re1 как int16
    fstp dword ptr [rcx+4*0]        ; Сохранение re1 как float

    fild word ptr [rsp+2*2]         ; Загрузка ro3 как int16
    fst dword ptr [rcx+4*10]        ; Сохранение ro3 как float
    fchs
    fstp dword ptr [rcx+4*14]       ; Сохранение -ro3 как float

    fldz                            ; Загружаем 0
    fst dword ptr [rcx+4*8]         ; Сохранение 0 как float
    fstp dword ptr [rcx+4*12]       ; Сохранение 0 как float

    fild word ptr [rsp+2*3]         ; Загрузка re3 как int16
    fst dword ptr [rcx+4*2]         ; Сохранение re3 как float
    fstp dword ptr [rcx+4*6]        ; Сохранение re3 как float

    fild word ptr [rsp+2*5]         ; Загрузка o3 как int16 на st
    mov [rsp+2*4], r11w             ; Загрузка на стек o1
                                    ; Стек(7): re5, re1, o2(ro3), e3(re3), o1, o3, e2
    fild word ptr [rsp+2*4]         ; Загрузка o1 как int16 на st
    fmul st(0), st(2)               ; sqrt(2)/2*o1
                                    ; ST: sqrt(2)/2*o1, o3, sqrt(2)/2

    fldz
    fadd st(0), st(1)               ; sqrt(2)/2*o1
    fsub st(0), st(2)               ; o3-sqrt(2)/2*o1=ro2
    fst dword ptr [rcx+4*9]
    fchs                            ; sqrt(2)/2*o1-o3=ro8
    fstp dword ptr [rcx+4*15]
                                    ; ST: sqrt(2)/2*o1, o3, sqrt(2)/2

    fadd st(0), st(1)               ; sqrt(2)/2*o1+o3=ro4
    fst dword ptr [rcx+4*11]
    fchs                            ; -sqrt(2)/2*o1-o3=ro6
    fstp dword ptr [rcx+4*13]
                                    ; ST: o3, sqrt(2)/2
    fstp st(0)                      ; Избавляемся от o3
                                    ; ST: sqrt(2)/2

    fild word ptr [rsp+2*6]         ; Загрузка e2 как int16 на st
    mov [rsp+2*5], r8w
    fild word ptr [rsp+2*5]         ; Загрузка e4 как int16 на st
    fmul st(0), st(2)               ; sqrt(2)/2*e4
                                    ; ST: sqrt(2)/2*e4, e2, sqrt(2)/2

    fldz
    fadd st(0), st(2)               ; e2
    fsub st(0), st(1)               ; e2-sqrt(2)/2*e4=re4
    fst dword ptr [rcx+4*3]
    fstp dword ptr [rcx+4*5]
                                    ; ST: sqrt(2)/2*e4, e2, sqrt(2)/2

    fadd st(0), st(1)               ; sqrt(2)/2*e4+e2=re2
    fst dword ptr [rcx+4*1]
    fstp dword ptr [rcx+4*7]
                                    ; ST: e2, sqrt(2)/2

    fstp st(0)                      ; Избавляемся от e2
    fstp st(0)                      ; Избавляемся от sqrt(2)/2
                                    ; ST: e2, sqrt(2)/2
    add rsp, 2*7                    ; Возвращаем адрес стека на прежнее положение

    ret
CalculateSpectrum ENDP
; ------------------------------------------------------------------------------------- ;
; void RecoverSignal(signal_type* Signal, spectrum_type* Spectrum)                      ;
;   Обратное преобразование Фурье. Вычисляет сигнал Signal по спектру Spectrum           ;
;   Типы данных spectrum_type и signal_type, а так же размер сигнала                  ;
;   определяются в файле Tuning.h                                                     ;
; ------------------------------------------------------------------------------------- ;
;
;  Spectrum = [a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7]
;
;          +---------------+   +-----+   +--+           +--------------------------------------------+   +-----------------------------+   +----+
;          |(a0+a4)+(a2+a6)|   |t1+t2|   |e1|           |               (a1+a7)+(a3+a5)              |   |             t3+t4           |   | o1 |
;          |(a0-a4)+(b6-b2)|   |k1+k2|   |e2|           | sqrt(2)/2*((a1+a7)-(a3+a5)+(b7-b1)+(b5-b3) |   | sqrt(2)/2*((t3-t4)+(k3+k4)) |   | o2 |
;          |(a0+a4)-(a2+a6)|   |t1-t2|   |e3|           |               (b7-b1)-(b5-b3)              |   |             k3-k4           |   | o3 |
;  Re(e) = |(a0-a4)-(b6-b2)| = |k1-k2| = |e4|   Re(o) = | sqrt(2)/2*(-(a1+a7)+(a3+a5)+(b7-b1)+(b5-b3)| = | sqrt(2)/2*(-(t3-t4)+(k3+k4))| = | o4 |
;          |(a0+a4)+(a2+a6)|   |t1+t2|   |e1|           |              -(a1+a7)+(a3+a5)              |   |-            t3+t4           |   |-o1 |
;          |(a0-a4)+(b6-b2)|   |k1+k2|   |e2|           |-sqrt(2)/2*((a1+a7)-(a3+a5)+(b7-b1)+(b5-b3) |   |-sqrt(2)/2*((t3-t4)+(k3+k4)) |   |-o2 |
;          |(a0+a4)-(a2+a6)|   |t1-t2|   |e3|           |              -(b7-b1)-(b5-b3)              |   |-            k3-k4           |   |-o3 |
;          |(a0-a4)-(b6-b2)|   |k1-k2|   |e4|           |-sqrt(2)/2*(-(a1+a7)+(a3+a5)+(b7-b1)+(b5-b3)|   |-sqrt(2)/2*(-(t3-t4)+(k3+k4))|   |-o4 |
;          +---------------+   +-----+   +--+           +--------------------------------------------+   +-----------------------------+   +----+
;
;                 +-----+         +--+
;                 |e1+o1|         |r1|
;                 |e2+o2|         |r2|
;                 |e3+o3|         |r3|
;  Signal = 1/8 * |e4+o4| = 1/8 * |r4|
;                 |e1-o1|         |r5|
;                 |e2-o2|         |r6|
;                 |e3-o3|         |r7|
;                 |e4-o4|         |r6|
;                 +-----+         +--+
;
RecoverSignal PROC                  ; [RCX] - Signal
                                    ; [RDX] - Spectrum
    finit
    fld dword ptr [rdx+4*0]         ; Загрузка a0
    fld dword ptr [rdx+4*4]         ; Загрузка a4
                                    ; ST: a4, a0
    fldz
    fadd st(0), st(2)               ; a0
    fsub st(0), st(1)               ; a0-a4=k1
    fxch st(2)                      ; ST: a0, a4, k1
    faddp st(1), st(0)              ; a0+a4=t1
                                    ; ST: t1, k1
    fld dword ptr [rdx+4*2]         ; Загрузка a2
    fadd dword ptr [rdx+4*6]        ; a2+a6=t2
                                    ; ST: t2, t1, k1
    fldz
    fadd st(0), st(2)               ; t1
    fsub st(0), st(1)               ; t1-t2=e3
    fxch st(1)
    faddp st(2), st(0)              ; t1+t2=e1
                                    ; ST: e3, e1, k1
    fld dword ptr [rdx+4*15]        ; Загрузка b7
    fsub dword ptr [rdx+4*9]        ; b7-b1=k3
                                    ; ST: k3, e3, e1, k1
    fld dword ptr [rdx+4*13]        ; Загрузка b5
    fsub dword ptr [rdx+4*11]       ; b5-b3=k4
                                    ; ST: k4, k3, e3, e1, k1
    fldz
    fadd st(0), st(2)               ; k3
    fsub st(0), st(1)               ; k3-k4=o3
                                    ; ST: o3, k4, k3, e3, e1, k1
    fldz
    fadd st(0), st(4)               ; e3
    fsub st(0), st(1)               ; e3-o3=r7
                                    ; ST: r7, o3, k4, k3, e3, e1, k1

    sub rsp, 2*8                    ; Бронируем 8 ячеек word в стеке
    fistp word ptr [rsp+2*7]        ; Сохраняем на стек как int16
                                    ; Стек(8): *, *, *, *, *, *, *, r7
                                    ; ST: o3, k4, k3, e3, e1, k1
    fadd st(0), st(3)               ; o3+e3=r3

    fistp word ptr [rsp+2*6]        ; Стек(8): *, *, *, *, *, *, r3, r7
                                    ; ST: k4, k3, e3, e1, k1
    fstp st(2)                      ; Избавились от e3
                                    ; ST: k3, k4, e1, k1
    faddp st(1), st(0)              ; k3+k4
                                    ; ST: k3+k4, e1, k1
    fld dword ptr [rdx+4*1]         ; Загрузка a1
    fadd dword ptr [rdx+4*7]        ; a1+a7=t3
                                    ; ST: t3, k3+k4, e1, k1
    fld dword ptr [rdx+4*3]         ; Загрузка a3
    fadd dword ptr [rdx+4*5]        ; a3+a5=t4
                                    ; ST: t4, t3, k3+k4, e1, k1
    fldz
    fadd st(0), st(2)               ; t3
    fadd st(0), st(1)               ; t3+t4=o1
                                    ; ST: o1, t4, t3, k3+k4, e1, k1
    fldz
    fadd st(0), st(5)               ; e1
    fsub st(0), st(1)               ; e1-o1=r5

    fistp word ptr [rsp+2*5]        ; Стек(8): *, *, *, *, *, r5, r3, r7
                                    ; ST: o1, t4, t3, k3+k4, e1, k1
    fadd st(0), st(4)               ; e1+o1=r1

    fistp word ptr [rsp+2*4]        ; Стек(8): *, *, *, *, r1, r5, r3, r7
                                    ; ST: t4, t3, k3+k4, e1, k1
    fsubp st(1), st(0)              ; t3-t4
                                    ; ST: t3-t4, k3+k4, e1, k1
    fld two                         ; Вычисление sqrt(2)/2
    fsqrt
    fdiv two
    fstp st(3)                      ; Избавляемся от e1
                                    ; ST: t3-t4, k3+k4, sqrt(2)/2, k1
    fldz
    fadd st(0), st(2)               ; k3+k4
    fsub st(0), st(1)               ; k3+k4-(t3-t4)
    fmul st(0), st(3)               ; sqrt(k3+k4-(t3-t4))=o4
    fxch st(2)                      ; ST: k3+k4, t3-t4, o4, sqrt(2)/2, k1

    faddp st(1), st(0)              ; k3+k4+(t3-t4)
    fmul st(0), st(2)               ; sqrt(k3+k4+(t3-t4))=o2
                                    ; ST: o2, o4, sqrt(2)/2, k1
    fld dword ptr [rdx+4*14]        ; Загрузка b6
    fsub dword ptr [rdx+4*10]       ; b6-b2=k2
                                    ; ST: k2, o2, o4, sqrt(2)/2, k1
    fldz
    fadd st(0), st(5)               ; k1
    fsub st(0), st(1)               ; k1-k2=e4
                                    ; ST: e4, k2, o2, o4, sqrt(2)/2, k1
    fldz
    fadd st(0), st(1)               ; e4
    fsub st(0), st(4)               ; e4-o4=r8

    fistp word ptr [rsp+2*3]        ; Стек(8): *, *, *, r8, r1, r5, r3, r7
                                    ; ST: e4, k2, o2, o4, sqrt(2)/2, k1
    fadd st(0), st(3)               ; e4+o4=r4
    fistp word ptr [rsp+2*2]        ; Стек(8): *, *, r4, r8, r1, r5, r3, r7
                                    ; ST: k2, o2, o4, sqrt(2)/2, k1
    faddp st(4), st(0)              ; k1+k2=e2
                                    ; ST: o2, o4, sqrt(2)/2, e2
    fldz
    fadd st(0), st(4)               ; e2
    fsub st(0), st(1)               ; e2-o2=r6
    fistp word ptr [rsp+2*1]        ; Стек(8): *, r6, r4, r8, r1, r5, r3, r7
                                    ; ST: o2, o4, sqrt(2)/2, e2
    fadd st(0), st(3)               ; e2+o2=r2
    fistp word ptr [rsp+2*0]        ; Стек(8): r2, r6, r4, r8, r1, r5, r3, r7
                                    ; ST: o4, sqrt(2)/2, e2
    fstp st(0)                      ; Избавились от o4
    fstp st(0)                      ; Избавились от sqrt(2)/2
    fstp st(0)                      ; Избавились от e2
                                    ; ST:

                                    ; Сохранение значений
    mov r8w, [rsp+2*0]              ; r2
    sar r8w, 3                      ; Смещение на 3 вправо (деление на 2^3)
    mov [rcx+1*1], r8b              ; Сохраняем как int8 (лишние байты от int16 не помешают)

    mov r9w, [rsp+2*1]              ; r6
    sar r9w, 3
    mov [rcx+1*5], r9b

    mov r10w, [rsp+2*2]             ; r4
    sar r10w, 3
    mov [rcx+1*3], r10b

    mov r11w, [rsp+2*3]             ; r8
    sar r11w, 3
    mov [rcx+1*7], r11b

    mov r8w, [rsp+2*4]              ; r1
    sar r8w, 3
    mov [rcx+1*0], r8b

    mov r9w, [rsp+2*5]              ; r5
    sar r9w, 3
    mov [rcx+1*4], r9b

    mov r10w, [rsp+2*6]             ; r3
    sar r10w, 3
    mov [rcx+1*2], r10b

    mov r11w, [rsp+2*7]             ; r7
    sar r11w, 3
    mov [rcx+1*6], r11b

    add rsp, 2*8                    ; Возвращаем адрес стека на прежнее положение
    ret
RecoverSignal ENDP
END