Kolokwium ASK

Zadanie 1:

Instrukcje z których można korzystać:
MOV A, B - kopiuje B do A
SHL A, B - przesuwa wszystkie bity A w lewo o ilość bitów zdefiniowaną przez B
SHR A, B - przesuwa wszystkie bity A w prawo o ilość bitów zdefiniowaną przez B
ADD A, B - sumuje A i B, wynik przechowuje w A
JZ etykieta - skok do etykiety jeżeli zero (ZF=1)
JNZ etykieta - skok do etykiety jeżeli nie zero (ZF=0)
POP A - zdejmuje ze szczytu stosu wartość i kopiuje ją do A
PUSH A - umieszcza A na szczycie stosu

    C:
    if (we == 0x7E) // 0x7E = 0111 1110
        wy = 0;
    else
        wy = 1;
-------------------------------------------------------------------------
    Assembler:
    mov al, we // Wrzucam we na rejestr al (8 bitowy bo char to zmienna 8 bitowa)
    mov bl, 0 // Wrzucam 0 na rejestr bl
    add al, 0x82 // Zamieniam liczbę 0x7E na liczbę ujemną - neguje oraz dodaje 1: 0x82 = 1000 0010
    jz etykieta1 // Jeżeli zero to skaczę do etykiety1 (liczby są sobie równe)
    add bl, 1 // Wrzucam 1 na rejestr bl gdy liczby nie są sobie równe
    etykieta1:
    mov wy, bl // Zawartość rejestru przerzucam do zmiennej wy (0 lub 1)
=========================================================================
Zadanie 2:

Instrukcje z których można korzystać:
MOV
SHL
SHR
ADD
JC etykieta - skok jeśli jest przeniesienie (CF=1)
JNC etykieta - skok jeśli nie ma przeniesienia (CF=0)
CLC - ustawia falgę CF na 0

    C:
    unsigned char we, wy;
    if (we < 0xCF)
        wy = 0;
    else
        wy = 1;

    //0CFh = 1100 1111
    //31h = 0011 0001
------------------------------------------------------------------------
    Assembler:
    CLC
    MOV al, 0
    ADD we, 0x31
    JC etykieta
    JMP etykieta2
    etykieta:
    MOV al, 1
    etykieta2:
    MOV wy, al
    // W skrócie: dodaje liczby do siebie i sprawdzam przeniesienie, jak wystąpiło to liczba jest większa
===========================================================================
Zadanie 3:

Instrukcje z których można korzystać:
MOV
SHL
SHR
SUB
JZ
JNZ
POP
PUSH

    C:
    unsigned char we;
    unsigned short wy;
    wy = we * 24;
    we * 24 = we(32 - 8)
------------------------------------------------------------------
    Assembler:
    MOV ax, 0 // zeruje ax
    MOV al, we // al = we
    SHL ax, 5 // ax = we * 32

    MOV dx, 0 // zeruje dx
    MOV dl, we // dl = we
    ; Chce pomnożyć przez 24 a mnożę przez 32, muszę teraz od ax odjąć we * 8 (pomnożyłem o 8 za dużo)
    SHL dx, 3 // dl = we * 8

    SUB ax, dx // (we * 32) - (we * 8) = we * 24
    MOV wy, ax
===================================================================
Zadanie 4:

    C:
    unsigned short we, wy
    wy = we * 2.625;
    // we * 2.625 = we * (2 + 5/8) = we * (2 + 1/2 + 1/8)
-------------------------------------------------------------------
    Assembler:
    mov ah, 0
    mov bh, 0
    mov ch, 0
    mov al, we
    shl ax, 1 // we * 2
    mov bl, we
    shl bx, 2 // we * 4
    mov cl, we
    add bx, cx // we * 4 + we = we * 5
    shr bx, 3 // 5/8
    add ax, bx //
    mov wy, ax
===================================================================
Zadanie 5:

Instrukcje z których można korzystać:
MOV
SHL
SHR
SUB
ADD
AND
SAR

SUMA ZER
-------------------------------------------------------------------
    Assembler:
    mov dl, 0
    mov cl, 0
    petla:
    mov bl, 8
    mov al, we
    shr al, cl
    and al, 0x1
    add dl, al
    add cl, 1
    sub bl, cl
    jz koniec
    jmp petla
    koniec:
    mov bl, 8
    sub bl, dl
    mov suma_zer, bl
====================================================================
SUMA JEDYNEK
--------------------------------------------------------------------
    Assembler:
    mov dl, 0
    mov cl, 0
    petla:
    mov bl, 8
    mov al, we
    shr al, cl
    and al, 0x1
    add dl, al
    add cl, 1
    sub bl, cl
    jz koniec
    jmp petla
    koniec:
    mov suma_jedynek, dl
====================================================================
Zadanie 6:

    C:
    typedef union
    {
        unsigned char BYTE;
        struct
        {
            unsigned char a:2;
            unsigned char b:3;
            unsigned char c:3;
        } bits;
    } un_x;

    un_x a = 0x5F;
    a.bits.c = a.bits.a;
    a.bits.b = a.bits.a;
---------------------------------------------------------------------
    Assembler:
    mov al, byte
    and al, 0x3 ; al=a
    mov bl, al
    shl bl, 2
    mov cl, al
    shl cl, 5
    or cl, bl
    or cl, al
    mov wy, cl
======================================================================
Zadanie 7:

    C:
    typedef union
        {
            unsigned char BYTE;
            struct
            {
                unsigned char a:2;
                unsigned char b:3;
                unsigned char c:3;
            } bits;
        } un_x;

        un_x a = 0x5F;

        a.bits.c = a.bits.a * a.bits.b;
----------------------------------------------------------------------
    Assembler:
    mov al, a
    and al, 0x1F
    mov bl, al
    and bl, 1 ; a = ?
    JZ etykieta
    mov bl, al ; b = ?
    and bl, 0x0E
    shl bl, 3
    or al, bl

    etykieta:
    mov wy, al
=======================================================================