1.Instrukcje operacji arytmetycznych z przykładowymi operandami( min. 5)
Add ax,bx
Adc ax,bx
Inc ax
Sub ax,bx
Sbb ax,bx
Dec ax
Neg ax
Mul bx,123
Imul bx,123
Div cx
Idiv cx

2.Instrukcje operacji logicznych (lub na bitach?) z przykładowymi operandami( min. 5)
And al,bl
Or al,bl
Xor al,bl
Not al

Shr al,1
Shl al,1
Sar al,1
Sal al,1
Ror al,2
Rol al,2

3.Instrukcje operujące na stosie (jawnie i nie jawnie) (min. 7)
Push ax
Pop ax
Pusha
Popa
Pushf
Popf

4.W jakim celu programista używa następujących instrukcji:
or ax, ax -??
xor ax, ax -??
xchng ax,ax -??
cbw - konwertuje bajt z rejestru al na słowo w rejestrze ax

5.jaki sposób (gdzie) funkcje języka C zwracają wartości typu:
char
int
long
char* (w modelu small)
jak wyżej

6.dana jest funkcja:
int copy(char *src, char *dst, int ile);
Jak dostać się do każdego argumentu funkcji z jej wnętrza? Narysować stosowny rysunek jak wygląda stos. Proszę założyć model pamięci large.
???

7.jakie są powody stosowania moułu Start up code?
Generuje startową sekwencję programu związaną z załadowaniem właściwą wartością rejestry segmentowe. i..?

8.Dyrektywy asemblera po co się stosuje? Wymienić 4 i opisać.(2ptk)
Są informacją dla assemblera (programu generującego kod wykonywalny) w jaki sposób program ma być tłumaczony.
ASSUME - przypisuje etykietę do wskazanego rejestru segmentowego
SEGMENT,ENDS - służą do deklaracji segmentów
GROUP- grupuje kilka segmentów
LABEL - tworzy etykiety przyporządkowując im aktualną wartość adresu

9.Cechy programu z rozszerzeniem .COM?(1ptk)
Składa się tylko z jednego segmentu, maksymalnie 64kb.Zawsze wykonywany od pierwszej instrukcji.

10.W jakim celu stosuje się funkcje setvect(); przed zakończeniem programu w którym
ożywaliśmy własnych przerwań?(1ptk)
Funkcja setvect() ustawia wektor przerwań. Po zakończeniu programu w którym używaliśmy własnych przerwań używamy tej funkcji aby przywrócić standardową wcześniej zapamiętaną obsługę przerwań.

------------------------------------------------------------------------------------------------------------------------------------

-Jaka jest zasadnicza różnica w treści asemblerowej funkcji obsługi przerwań od zwykłej funkcji?(1pkt)

-Dyrektywy asemblera po co się stosuje? Wymienić 4 i opisać.(2ptk)

-Dwa zadania ze stosami jedno dla small drugie dla large
- Moduł StartUp:
-bez niego nie mozliwe jest wywołanie funkcji main()
-zawiera wszystko co jest uruchamiane przed wywołaniem main()
-ustawia wartość zmiennych globalnych
-przygotowuje środowisko do uruchomienia programu i sprząta po jego wykonaniu

-generuje kod startowy w programach MS-DOS
-zwykle umieszczony tuż po .CODE
-generuje startową sekwencje programu związaną z załadowaniem wartości do rejestrów segmentowych
-jest to kod przygotowujący sprzęt do wykonania programów w języku wysokiego poziomu np.C
-inicjuje obszar danych programu ustawia wskaźnik stosu

-W jakim celu programista używa następujących instrukcji:
or ax, ax
xor ax, ax
xchng ax,ax
cbw

-Cechy programu z rozszerzeniem .COM?(1ptk)

kod (cs) jak i dane (ds) programu muszą się zmieścić w 64k program będzie się zaczynać od CS:0100H

szerszy opis:

Po załadowaniu do pamięci programu typu COM system operacyjny(DOS) nadaje wszystkim 4 rejestrom segmentowym taka samą wartość odpowiadającą segmentowi do którego program załadowano, a następnie przekazuje sterowanie programem do instrukcji znajdującej się od 256 bajtu (100h) za początkiem segmentu kodu , zawartość rejestru IP wynosi wiec 0100H. Tych pierwszych 256 bajtów segmentu kodu zajmuje tzw. blok lub nagłówek PSP-przedrostek segmentu programu. Pierwsza instrukcja w programie ma adres CS:0100H dlatego na początku programu typu COM umieszcza się dyrektywę ORG 0100H.

-W jakim celu stosuje się funkcje setvect(); przed zakończeniem programu w którym używaliśmy własnych przerwań?(1ptk)

przywrocenia vektora przerwań

-w jaki sposób (gdzie) funkcje języka C zwracają wartości typu:
char
int
long
char* (w modelu small)

char do al bo 1bajt
int do ax bo 2bajty
long do eax bo 4bajty
char* (w modelu small) tutaj nie jestem pewien ale chyba ax(2bajty) a dla large eax(4bajty)

-jakie są powody stosowania moułu Start up code?
-wymień cechy programu *.com

-jaka jest zasadnicza różnica w treści asemblerowej funkcji obsługi przerwań od zwykłej funkcji?
Po pierwsze funkcja taka nie może ani zwracać wartości ani przyjmować argumentów...
Po drugie mniej ważne, kładzie się flagi na stos oraz wraca się z niej IRET...
-dlaczego na końcu programu w którym używano własnych funkcji obsługi przerwań stosowana jest funkcja setvect(); oraz co jest jej argumentem?

-dana jest funkcja:
int copy(char *src, char *dst, int ile);
Jak dostać się do każdego argumentu funkcji z jej wnętrza? Narysować stosowny rysunek jak wygląda stos. Proszę założyć model pamięci large.

int copy(char *src, char *dst, int ile); LARGE Na początku mamy pseudo pusty stos (tzn coś na nim jest, ale nie jest istotne z punktu widzenia wywołania tej funkcji). Argumenty na stosie kładzie się od końca. Komórka stosu zajmuje 2 bajty czyli 1 słowo. Kładziemy na stos po kolei: ile, dst, src. Jesteśmy w modelu large, wywołując funkcję musimy pamiętać segment z którego przyszliśmy, kładziemy na stos rejestr cs (bieżący segment kodu, funkcja może być w innym segmencie). Potem wywołujemy call _copy. Instrukcja call kładzie na stosie rejestr ip - numer bajtu w segmencie kodu, rejestr ip decyduje o tym który rozkaz ma być wykonany jako następny; call zastępuje rejestr ip offsetem funkcji którą wywołaliśmy. Wewnątrz funkcji bezpośrednio po wywołaniu jest sekwencja rozkazów: push bp mov bp, sp Kładzie na stos rejestr bp (base pointer - wskaźnik bazowy, względem którego obliczane jest położenie danych na stosie), każda funkcja liczy od swojego bp, dlatego tu musimy zapamiętać jakie bp było wcześniej, a potem bierzemy sp (wierzchołek stosu) i ładujemy go do bp (wskaźnika bazowego naszej funkcji). //To co wyżej było położone wcześniej, wierzchołek stosu jest na dole. Kod: +--------------------------+ |              ile         | +--------------------------+<--- bp+14 |segment wskaźnika dst      | +--------------------------+<--- bp+12 |offset wskaźnika dst       | +--------------------------+<--- bp+10 |segment wskaźnika src      | +--------------------------+<--- bp+8 |offset wskaźnika src       | +--------------------------+<--- bp+6 |              cs          | +--------------------------+<--- bp+4 |              ip          | +--------------------------+<---  bp+2 |              bp          | +--------------------------+<--- tu wskazuje sp i bp Jak już wspomniałem wcześniej adresy obliczane są względem rejestru bp. Dostęp do zmiennych: Kod:   zmienna        dostęp +---------------+--------------------------+ |    ile        | word ptr [bp+14]         | +---------------+--------------------------+ |    dst        | dword ptr [bp+10]        | +---------------+--------------------------+ |    src        | dword ptr[bp+6]          | +---------------+--------------------------+ W modelu SMALL na stosie nie będzie: segmentu dst, segmentu src, cs. word - słowo - 2 bajty dword (double word) - podwójne słowo - 4 bajty

Instrukcje operujące na stosie (jawnie i nie jawnie) (min. 7) - z opisem
PUSH src; kładzie na stosie słowo (2B) z src (np. ax, si)
PUSHA ; odkłada na stos rejestry w kolejności ax, cx, dx, bx, sp, bp, si, di
PUSHF ; kładzie flagi na stosie (rejestr (E)Flags)
POP desc ; ściąga słowo (2B) ze stosu i przepisuje wartość do desc (np. cx)
POPA ; ściąga ze stosu rejestry ogólnego przeznaczenia: di, si, bp, sp, bx, dx, cx, ax
POPF ; zdejmuje ze stosu słowo (2B) i kopiuje do dolnych (16b) rejestru (E)Flags (przywraca flagi)
RET ; zależnie od zasięgu (far/near) ściąga ze stosu IP i ew. cs i skacze pod adres CS:IP
RETN ; jw. tylko IP
RETF ; jw. cs i IP
IRET/IRETD ; powrót z przerwania j.w IP, CS, Flags
CALL (NEAR) desc ; call bliskie; kładzie na stos adres powrotu z procedury
CALL (FAR) desc ; call dalekie; kładzie na stos rejestr segmentowy cs i adres powrotu z procedury

Te są tak pośrednio na samym stosie
LEAVE ; Zwalnia pamięć zarezerwowaną na stosie dla zmiennych lokalnych utworzoną przez ostatnią instrukcję ENTER
ENTER ; rezeruje pamięć na stosie
ADD SP, immed ; przesuwa wskaźnik stosu (np. ADD sp, 6)

or ax, ax -> ustawianie odpowiednich flag (CF OF PF SF ZF); zwykle przed rozkazem skoku warunkowego
xor ax, ax -> szybsze zerowanie rejestru niż mov ax,0 (ax <- 0) to samo SUB rej,rej.
xchng ax,ax -> odpowiednik funkcji NOP(pustej); zamienia zawartość ax z ax
cbw -> Zamienia wartość typu bajt znajdującą się w AL na wartość typu WORD (16-bitów) znajdującą się w AX wypełniając AH wartością najbardziej znaczącego bitu w AL (czyli zachowuje znak) używane np. przy operacjach dzielenia, mnożenia, rzutowania niejawnego (int <- char)
cwd -> Zamienia wartość typu WORD zawartą w rejsetrze AX na wartość typu DWORD zawartą w rejestrzee DX:AX wypełniając DX wartością najbardziej znaczącego bitu w AX.

-jak w small i large wyglada na stosie wskaznik to zmiennej ktora sama jest DWORD? ile zajmuje bajtow

w modelu large masz segment o offset, les wydobywa segment z DWORD'a (czyli dane) i pozwala na ich zapis do innych zmiennych/rejestrów.
np:

Kod:

; *ptr++=1; //small ; mov bx,word ptr DGROUP:_ptr // wpisuje do rejestru bx adres ze wskaźnika ptr, mov byte ptr [bx],1 // pod adres na który wskazuje ptr wpisuje wartośd 1 //large les bx,dword ptr DGROUP:_ptr //les ładuje es z miejsca pamięci wskazywanego przez ptr do rejestru bx mov byte ptr es:[bx],1 //zapisanie pod wskazany adres 1 inc word ptr DGROUP:_

les bx, DGROUP _zmienna
'es' z nazwy rozkazu mówi o tym, że segment zostanie załadowany do rejestru es. O ile dobrze pamiętam les używa się ?tylko? w modelu large. Offset idzie do pierwszego argumentu czyli rejestru bx. _zmienna może zajmować nawet megabajta, wskaźnik jest na jej początek i zawsze zajmuje tyle samo, w large 4bajty, w small 2 bajty.

Wskaźnik na stosie w modelu small zajmuje jedną komórkę stosu (2 bajty). W modelu small wskaźnik zajmuje 2 komórki (4 bajty). Starsza część wskaźnika (segment) jest na stosie położony najpierw, młodsza część (offset) później. Btw rozrysowałem to parę postów wcześniej dla large.

Co do koprocesora arytmetycznego... chodziło oczywiście o operacje działające na liczbach zmiennoprzecinkowych wykorzystujące rejestry ST takie jak FADD FABS, FSUB, FMUL, FDIV, itd. (F na początku)...

A tutaj komentarz zadowolonego studenta który pisał to 2 lata temu:

„ale nas rozjebał tymi pytaniami”

---