extended-precision-arithmetic/fix_mul.asm at master · ppommer/extended-precision-arithmetic · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
section .data
global fix_mul_asm
extern fix_add_asm

section .text

;[ebp + 12][ebp + 08] * [ebp + 20][ebp + 16]
;-------------------------------------------
;                       [--edx1--][--eax1--]
;          [--edx2--]   [--eax2--]
;          [--edx3--]   [--eax3--]
;[--edx4--][--eax4--]
;-------------------------------------------
;[--------][--edx---]   [--eax---][--ebx---]

fix_mul_asm:
    push ebp
    mov ebp, esp

    push ebx
    push ecx
    push esi

    ; prüfen, ob Zahlen negativ
    mov esi, 0 ; esi speichert Anzahl negativer Zahlen

    ; Zahl 1 überprüfen
    mov edx, [ebp + 12]
    mov eax, [ebp + 8]

    test edx, edx ; edx negativ?
    jns skip_1 ; falls nein, ueberspringe Umwandlung

    inc esi ; Anzahl negativer Zahlen: 1
    not edx ; edx invertieren
    not eax ; eax invertieren

    add eax, 1 ; eax + 1
    adc edx, 0 ; ggf. Carry-bit zu edx addieren

    mov [ebp + 12], edx ; edx zurückschreiben
    mov [ebp + 8], eax ; eax zurückschreiben

    skip_1:
        ; Zahl 2 überprüfen
        mov edx, [ebp + 20]
        mov eax, [ebp + 16]

        test edx, edx ; edx negativ?
        jns skip_2 ; falls nein, ueberspringe Umwandlung

        inc esi ; Anzahl negativer Zahlen: 2
        not edx ; edx invertieren
        not eax ; eax invertieren

        add eax, 1 ; eax + 1
        adc edx, 0 ; ggf. Carry-bit zu edx addieren

        mov [ebp + 20], edx ; edx zurückschreiben
        mov [ebp + 16], eax ; eax zurückschreiben

    skip_2:
        ; [ebp + 08] * [ebp + 16]
        mov eax, [ebp + 8]
        mov ecx, [ebp + 16]
        mul ecx ; edx:eax = [ebp + 08] * [ebp + 16]

        mov ebx, eax ; eax1 sichern

        push dword 0 ; 0 auf Stack
        push edx ; edx1 auf Stack

        ; [ebp + 08] * [ebp + 20]
        mov eax, [ebp + 8]
        mov ecx, [ebp + 20]
        mul ecx ; edx:eax = [ebp + 08] * [ebp + 20]

        push edx ; edx2 auf Stack
        push eax ; eax2 auf Stack

        call fix_add_asm
        add esp, 16

        push edx ; 0 + edx2 auf Stack
        push eax ; edx1 + eax2 auf Stack

        ; [ebp + 12] * [ebp + 16]
        mov eax, [ebp + 12]
        mov ecx, [ebp + 16]
        mul ecx ; edx:eax = [ebp + 12] * [ebp + 16]

        push edx ; edx3 auf Stack
        push eax ; eax3 auf Stack

        call fix_add_asm
        add esp, 16

        push edx ; edx2 + edx3 auf Stack
        push eax ; edx1 + eax2 + eax3 auf Stack

        ; [ebp + 12] * [ebp + 20]
        mov eax, [ebp + 12]
        mov ecx, [ebp + 20]
        mul ecx ; edc:eax = [ebp + 12] * [ebp + 20]

        push eax ; eax4 auf Stack
        push dword 0

        call fix_add_asm
        add esp, 16

        ; Ergebnisraum um 6 bit nach links shiften

        ; 1: obere 6 bit aus eax in die unteren 6 bit in edx kopieren
        shl edx, 6 ; edx um 6 nach links shiften
        mov ecx, eax ; eax in Hilfsregister ecx kopieren
        shr ecx, 26 ; nur die obersten 6 bit behalten
        or edx, ecx ; untere 6 bit aus Hilfsregister ecx in Zielregister edx übertragen

        ; 2: obere 6 bit aus ebx in die unteren 6 bit in eax kopieren
        shl eax, 6 ; eax um 6 nach links shiften
        shr ebx, 26 ; nur die obersten 6 bit behalten
        or eax, ebx ; untere 6 bit aus Hilfsregister ecx in Zielregister eax übertragen


        ; falls eine der beiden Zahlen negativ war, Ergebnis invertieren
        cmp esi, 1
        jne skip_umwandlung

        not edx
        not eax

        add eax, 1
        adc edx, 0

        skip_umwandlung:
            ; aufräumen
            pop esi
            pop ecx
            pop ebx

            pop ebp

            ret