MartyWiki

; Vyčti dvě čísla z paměti (x, y), proveď sečtení a odečtení, ulož výsledky do paměti (r1, r2).
; Můžeš je vypsat i na stdout
 
%include "rw32.inc"
 
section .data
    ; unsigned char x = 98; y = 15;
 
section .bss
    ; unsigned char r1, r2;
 
section .text
main:
    ; unsigned char r1 = x + y;
 
    ; unsigned char r2 = x - y;
 
    ret

; UKÁZKA
; Sledovaní příznaků registru (E)FLAGS
%include "rw32.inc"
 
section .text
main:
    mov eax,0  ; na začátek vynuluju celé EAX
    mov al, 126 ; do 8-bit registru vložím vysokou hodnotu
    add al, 1  ; zvýším
    add al, 1  ; zvýším, přetečení, OF=1, SF=1
    add al, 1  ; OF=0, zůstává SF=1
    add al, 1
    add ax, 1  ; CO SE STANE? ... SF=0, protože větší register
    inc al     ; SF=1 je zpět!
    nop
 
    mov eax, 0  ; na začátek vynuluju EAX, ale FLAGY zůstávají
    mov eax, 2  ; vložím hodnotu 2
    sub eax, 1  ; odečtu 1, nic se neděje
    sub eax, 1  ; CO SE STANE? ... odečtu 1, výsledek po operaci je 0, ZF=1
    sub eax, 1  ; odečtu 1, jsem v záporu, CF=1, SF=1, ZF=0
                ; v případě instrukce "dec" je CF=0
    nop
    ret

%include "rw32.inc"
 
section .data
    x   dd  0x4FE8AAFF  ; unsigned long
    y   dd  0x10203040  ; unsigned long
    r   dd  0
 
section .text
main:
    ; Sečti čísla x a y s použitím jediného 8-bitového registru, výsledek do r.
    ; Hint: Sčítej jako na základce, dvě čísla pod sebou.
    ;       mov al, [x + 0]   ; od nejníže významového byte
    ; Výsledek 0x6008DB3F
 
    ret

; Ukázka MUL a DIV
%include "rw32.inc"
 
section .data
    a   db  5
    b   db  10
    v   dw  0
 
section .text
main:
    ; v = a * b
 
    mov al, [a]
    mul byte [b]  ; Op=byte: AX:=AL*Op
    mov [v], ax
    nop
 
    ; v = b / a
 
    xor eax, eax
    mov al, [b]
    div byte [a]  ; Op=byte: AL:=AX / Op  ; výsledek v AL, zbytek v AH
    mov [v], al
 
    ret

; Ukázka MUL násobení větších čísel
%include "rw32.inc"
 
section .data
    a   dw  30
    b   dw  10
    v   dd  0
 
section .text
main:
    ; v = a * b
 
    mov eax, 0x77770000    ; pro ukázání změn v debuggeru
    mov edx, 0x77777777    ; pro ukázání změn v debuggeru
    nop
    mov ax, [a]
    mul word [b]
    mov [v + 0], ax
    mov [v + 2], dx
    nop
    mov eax, [v]    ; abych viděl správně výsledek
    nop
 
    ; v = a / b
 
    xor eax, eax
    xor edx, edx
    mov ax, [a]  ; dělenec v DX:AX, dělitel v [b]
    div word [b] ; celočíselný výsledek v AX, zbytek v DX
 
    ret

%include "rw32.inc"
 
section .data
    a   dw  10
    c   dw  20
    v   dw  5
 
section .text
main:
    ; Vypočítej obsah lichoběžníku a vypiš výsledek
 
 
    ret

; Ukázka MOVZX, MOVSX
 
%include "rw32.inc"
 
section .data
    a   db  -1 ; == 255
    b   db  -1
    v   dw  0
 
section .text
main:
    ; char a = -1; b = -1;
    ; shor v = a + b;
 
    mov ax,0xffff
    movzx ax, byte [a]  ; bez znaménka
    movzx dx, byte [b]
    add ax,dx   ; proč je výsledek 510??
    mov [v],ax
 
    mov ax,0x7F7F
    movsx ax, byte [a]  ; se znaménkem
    movsx dx, byte [b]
    add ax,dx   ; je CF, ale není OF
    mov [v],ax
 
    ret

; Ukázka rozšíření znaménka CBW, CWD, CDQ
%include "rw32.inc"
 
section .text
main:
    xor eax, eax
    mov al, 125  ; bez znaménka, nejvyšší bit je 0
    cbw
    mov al, 129  ; == -127
    cbw   ; AL -> AH:AL
    nop
 
    xor eax, eax
    mov ax, 0x5555  ; bez znaménka
    cwd   ; AX -> DX:AX
    mov ax, 0xF5F5  ; se znaménka
    cwd   ; AX -> DX:AX
    nop
 
    mov eax, 0x22BB22BB
    mov edx, 55  ; random číslo, které bude přepsáno
    cdq   ; EAX -> EDX:EAX
    mov eax, 0xFFBBFFBB
    cdq   ; EAX -> EDX:EAX
    nop
    ret

; Solo úkol (násobení, sčítání, práce s polem)
%include "rw32.inc"
 
section .data
    ceny   ; TODO
    pocty  ; TODO
 
section .text
main:
    ; Vyúčtování v restauraci
    ; Pivo   30,-  8x
    ; Víno   50,-  3x
    ; Kofola 25,-  4x
    ; Ceny inicializuj do pole doublů
    ; Počty inicializuj do pole wordů
    ; Vypočítej celkovou sumu a výsledek ulož do EAX
 
    mov eax, 0
    mov ebx, 0
    mov edx, 0
 
    ; TODO
 
    call WriteUInt32
    ret

; Vypočítej výraz y=((a*2)-b+(c/4))%3
; kde a, b a c jsou ukazatele na hodnoty o velikosti 16 bitů.