Artykuł ten zaadresowany jest do osób chcących połączyć wysoki
poziom języka Pascal z efektywnością Assemblera - językiem
niskiego poziomu. Nie trudno jest zauważyć korzyści wynikające z tego związku. Szybkość w grafice i obliczeniach matematycznych,
zwięzłość i mała objętość kodu wynikowego, no i panowanie nad wszystkimi elementami komputera. Za to Pascal wnosi łatwość
pisania interfejsów dla aplikacji i udogodnienia wynikające z wysokiego poziomu języka. Wady we wstawkach assemblerowych
widzę tylko dwie, odziedziczone po samym Assemblerze:
trudność w pisaniu w języku niskiego poziomu i nieczytelność
kodu.

Więc jeśli potrzebujesz dużej szybkości, precyzji działania i totalnej kontroli nad swoimi programami pisanym w Pascalu, to nie widzę przeszkód aby wykorzystać wstawki Assemblera. No chyba, że nie wiesz nic o programowaniu w Assemblerze. Wtedy
prawdopodobnie nie zrozumiesz tego tekstu, to nie jest kurs dla (t)opornych typu "Nie tylko dla orłów" ;) Powinieneś najpierw
przeczytać jakieś kursy dla początkujących. Taka wiedza wystarczy aby dobrze zrozumieć treść tego artykułu. Co trudniejsze rzeczy wytłumaczę.

Jeśli jakiś fragment kodu nie chce się skompilować na twoim kompilatorze, to albo został wyrwany z kontekstu, albo używamy innej implementacji języka Pascal. Moja to Borland Turbo Pascal 7 - wersja szkoleniowa ;)

1. O Assemblerze.

Przypomnę najważniejsze rzeczy, jakie będą nam potrzebne,
aby w ogóle skorzystać ze wstawek. Nie jest tego dużo ale jest to nieodzowna część wstawek Assemblerowych (no może z wyjątkiem
kilku zagadnień, które wstawiłem jako ciekawostkę ;).

a) Skoki warunkowe

Instrukcje do procesora przekazywane są w kolejności
występowania w pamięci po kolei. Instrukcja, wskazywana przez CS:IP (lub CS:EIP dla programów 32 bitowych w trybie chronionym procesora - trudno jednak jest znaleźć implementację Pascala,
która to obsługuje, więc nie będę tego tu omawiał) przekazywana
jest procesorowi, następnie zwiększana jest wartość IP o wielkość poprzedniej instrukcji, tak aby wskazywał na następną. Sęk w tym,
że "trudno" jest zmienić samemu wartość IP (z założenia jest on
nie dostępny dla programisty, lecz można to ominąć ;). Aby manipulować skokami procesora w pamięci, można wykorzystać
skoki warunkowe lub bezwarunkowe.

Ogólna instrukcja skoku bezwarunkowego ma postać:

JMP @SKACZ
//to omijamy
@SKACZ:
//to robimy

Jest to jedna z częściej wykorzystywanych instrukcji. Inne skoki
(już warunkowe) to: JA, JB, JE (jeżeli nich nie pamiętasz, to powtórz materiał z innych kursów ;), wykorzystuje się je tak samo jak skoki bezwarunkowe:

CMP AX, BX
JA @WIEKSZE
//no i co ?
@WIEKSZE
//rób coś

Jak zapewne zauważyłeś, samo tworzenie etykiet - jak i skoki - wyglądają tak samo jak w standardowym kompilatorze
Assemblera. Myślę, że nie powinno być z ich obsługą we wstawkach problemów.
Skoków warunkowych jest więcej, wybrałem moje ulubione. Warto także podkreślić, że na nowszych procesorach (Pentium) te skoki zajmują tylko jeden takt procesora.

b) Stos

Sama obsługa stosu we wstawkach wygląda tak samo, jak w
czystym Assemblerze. Z tą różnicą, że tu nie trzeba martwić się deklaracją stosu, ani przepełnieniem. O wszystko zatroszczy się kompilator - najczęściej program zakańcza się z komunikatem przepełnienia stosu ;)

Mam nadzieję, że każdy pamięta zastosowanie i obsługę instrukcji PUSH reg, POP reg, PUSHF, POPF, PUSHA, POPA. Generalna zasada
to: "ile razy push`ujesz, tyle pop`ujesz" ;). Jeżeli nie zdejmiesz push`owanej wartości ze stosu, to wywołana funkcja nie powróci
w miejsce wywołania. Najgorsze jest to, że trudno jest wykryć takie błędy (co sprytniejsi piszą programy do zliczania liczby PUSH`ów i POP`ów w kodzie źródłowym ;).

c) Wywoływanie procedur

Aby we wstawce wywołać procedurę bez argumentów, napisaną
w Assemblerze lub w Pascalu, stosuje się instrukcję CALL
nazwa. Np.:

//...
MOV AL, BH
OUT 42h, AL.
//delay
CALL NOSOUND

Nie ma w tym wiele filozofii. Problemy mogą być w wywoływaniu funkcji (lub procedur) z argumentami (lub parametrami - bardziej znane określenie dla Pascala), a później w pobraniu wyników od
nich. Ale o tym później.

Trzeba jednak pamiętać, że każde skoki procesora w inny segment zajmują cenne takty, im więcej takich wywołań, tym wolniej działa program. Tak samo nie można przedobrzyć ze przerwaniami.

d) Koprocesor (FPU)

FPU (Floating Point Unit) jest bardzo przydatny gdy chcemy
zwiększyć szybkość wykonywania obliczeń matematycznych. Jego instrukcje najczęściej można spotkać we wstawkach Assemblera.

Nie będę wymieniał listy komend koprocesora. Trzeba tylko
pamiętać, że na początku stawia się F..., później nazwa instrukcji (często analogiczna do instrukcji CPU) np. FADD. Gdy chcemy użyć
liczb całkowitych (co zresztą jest nie naturalne dla koprocesora, musi on wykonać konwersję do liczb rzeczywistych - co zajmuje czas) dodajemy po F.. I(i) np.: FIADD.

Przed użyciem FPU trzeba go najpierw zainicjować (zresetować) (FINIT). Często jest to jednak pomijane.

2. Co z tymi wstawkami?

Przejdźmy do sedna sprawy. Są trzy możliwe sposoby pisania wstawek. Wszystkie mają swoje plusy i minusy ;)

a) Asm statement

Nie jest to polska nazwa, ale nigdzie nie widziałem innej
(wprawdzie tekstu o wstawkach Assemblera też nigdzie nie widziałem ;).

Wstawka ta ma postać:

//tekst w Pascalu
Asm
//instrukcje, nie potrzeba średnika
End;
//tekst w Pascalu

Np.:

Begin
WriteLn('Przed asm...');
Asm
Mov AX, BX
Mov CX, BX; SHL AX, CX {komentarz}
End;
WriteLn('Po end;');
End.

Ten przykład praktycznie nic nie robi. Ale ilustruje sposób użycia
wstawek ;) Zauważ, że nie trzeba stawiać średników po
pojedynczej instrukcji (w jednej linijce). Gdy chcemy wstawić wiele
instrukcji w jednej linijce trzeba je odseparować średnikiem.
Komentarze mają styl Pascala.

Ten typ wstawek wykorzystuje się zwłaszcza, gdy chcemy w kodzie Pascala, bez większej zabawy, użyć instrukcje Assemblera. Można
je wykorzystać wszędzie: w głównym bloku, w funkcjach i procedurach. Ich liczba nie jest ograniczona, mogą następować po sobie.

Ma ona jednak swoje minusy. Rozważmy przykład:

Asm
Mov AX, BX
Jmp @ETYKIETA
End;
WriteLn('Tekst');
Asm
@ETYKIETA:
Mov DS, AX
End;
WriteLn('Tekst');

Wbrew pozorom ten kod nie skompiluje się. Etykiety stawiane w jednym bloku asm-end nie są znane w innych blokach.

W tych wstawkach mogą być dowolnie modyfikowane następujące rejestry CPU: AX, BX, CX, DX, SI, DI, ES i flagi. Poprzedni przykład
miał jeszcze jeden błąd. Rejestr DS został zmieniony (choć samo
w sobie to nie jest błąd), ale jego wartość nie została przywrócona
do pierwotnego stanu. Następna instrukcja WriteLn() prawdopodobnie wypisała by bzdury - dla niej DS miał wskazywać
na segment w którym jest 'Tekst'. Można się przed tym uchronić
stosując PUSHA, np.:

Asm
PUSHA
Mov AX, 01234h
Mov DS, AX
POPA
End;
WriteLn('Tekst2');

Teraz wszystko jest ok. Rejestr DS nie jest jedynym, którego wykorzystuje Pascal, gdy inicjuje wstawki. Reszta to: BP, SP, SS,
no i DS. Te reguły odnoszą się też do reszty wstawek.

b) Funkcja Assemblerowa

Jest to rodzaj wstawki, który może występować tylko w funkcjach i procedurach. Obejmuje całą funkcję (procedurę). Ma następujące właściwości: nie jest generowany kod inicjacji zmiennych, jeżeli nie występują parametry, nie jest inicjowany stos, odwołanie się do @Result jest błędem (o @Result później).

Jako, że parametry nie są inicjowane wszystkie są traktowane tak,
jak by miały znacznik VAR i nie mogą być zmieniane (a przynajmniej nie powinny).

A oto jak wygląda Funkcja Assemblerowa:

Function Nazwa(x,y :integer); Assembler;
Asm
Mov AX, x
End;

Zaraz po średniku występuje dyrektywa Assembler informująca kompilator o rodzaju funkcji. Zamiast Begin występuje słowo
kluczowe Asm. Funkcja kończy się - jak każda - End`em.

c) Inline

Instrukcja Inline jest przeznaczona do umieszczania w programie kodu maszynowego. Posługiwanie się funkcją inline (tak naprawdę
to nie jest funkcja, tylko tak wygląda ;) jest bardzo skomplikowane, czasochłonne i podatne na błędy. Ponadto nigdy nie znalazłem sensownego zastosowania dla niej. Kod maszynowy bardziej wygodnie - jak dla mnie - jest wstawiać w zwykły blok Assemblera
(o tym później).

Zdecydowałem się nią tu opisać, ponieważ często pojawia się we wstawkach Pascala. Oto przykład takiej instrukcji:

Begin
inline(
$B8/$00/$4C/ {mov ax, 4c00h}
$CD/$21 {int 21h}
);
Write('Co??'); {tu nigdy nie dojdzie ;}
End.

Najpierw opiszę przykład, następnie wyjaśnię konstrukcję instrukcji inline.

W kodzie Pascala cała instrukcja inline (każda z osobna oczywiście) jest traktowana jako całość. Nie wykonuje (podczas np.: debbuging`u) pojedynczo każdej fizycznej instrukcji procesora
tylko wszystkie na raz - cały blok inline. Tutaj napisałem
maszynowo instrukcję DOS`a zamykającą program. Procedura
Write() nigdy nie zostanie wykonana.

Ważne: Kompilator całą zawartość instrukcji inline "wszywa" w kod programu NIE sprawdzając jej zawartości. Nieważne jakie bzdury napiszemy, zawsze zostanie skompilowane. (Można to oczywiście wykorzystać do pisania najnowszych instrukcji naszego procesora
w starych kompilatorach Pascala).

Konstrukcja instrukcji inline jest bardzo prosta. Ilość danych jest nieograniczona.
Inline(kod/kod
kod/kod);
Wcięć nie musimy robić, tak jak komentarzy, są dla naszej wygody.

3. Zwracanie wyniku funkcji.

Ze wstawkami często tak jest, że w 80% przypadków są to
funkcje. Rozważmy następujący przykład:

Function Dodaj(a, b:word):word;
Var temp:word;
Begin
Asm
Mov ax, a
Mov bx, b
Add ax, bx
Mov temp, ax
End;
Dodaj := temp;
End;

Jest to oczywiście poprawny kod, ale ma swoje wady. Po pierwsze trzeba tworzyć zmienną tymczasową (w tym wypadku Temp).
Może to być nie pożądane, gdy operujemy na dużych zmiennych. Po drugie trzeba przerywać Asm-end; Także nie wygląda to najlepiej ;)

a) @Result

Podstawową formą zwracania wyniku z funkcji, w której
zastosowano Asm-statement jest zmienna @Result . Jest ona
powiązana referencją do zmiennej trzymającej wynik funkcji.

Używa się jej tak, jakby był zwykłą zmienną. Można wykonywać na niej wszystkie operacje matematyczne. Jej typ jest ustalany na podstawie typu funkcji. Można więc napisać:

function dodaj(a,b :single):single;
begin
asm
fld a {włożenie na stos zmiennej 'a'}
fld b
fadd
fst @Result
{zdjęcie wierzchołka stosu do zmiennej @Result}
end;end;

Powiedzmy wprost. Konstruktorzy Pascala nie mogli wymyślić nic lepszego nad @Result.

b) Funkcje Assemblerowe

Sprawa nie wygląda już tak prosto i wspaniale w odniesieniu do funkcji Assemblerowych. Tutaj konstruktorzy Pascala dali plamę wycofując referencję @Result. Pewnie mieli jakieś powody, ale ja
nie znalazłem żadnej dobrej strony tej decyzji (lub niedopatrzenia).

Z tego powodu jednak nie można zrezygnować z funkcji Assemblerowych, trzeba dać sobie radę inaczej ;)

Zwracanie wyniku zależy od jego typu.

Typy 8-bitowe zwraca się w rejestrze AL. Zmienne 16-bitowe
zwraca się w rejestrze AX. Natomiast wyniki 32-bitowe zwraca
się w parze rejestrów DX-AX. Tzn.: DX jest starszym słowem
zmiennej, AX młodszym. Gdy zwraca się liczbę rzeczywistą,
to wynik pobierany jest ze szczytu stosu koprocesora.

Jeżeli funkcja zwraca typ String, to należy zdjąć ze stosu dwie
wartości, najpierw segment, potem offset. Razem to tworzy adres
do Stringa. (Pamiętaj, że na początku Stringa jest bajt określający
ilością elementów).

Na początek wydaje się to skomplikowane, w rzeczywistości tylko
zwracanie zmiennych 32-bitowych przysparza małe kłopoty.
Pokażę jeszcze małą funkcję prezentującą główną ideę:

function dodaj(a,b :word):word;Assembler;
asm
mov cx, a
mov bx, b
add cx, bx
mov ax, cx {Wynik w AX}
end;

4. Obsługa funkcji we wstawkach.

Poprzednio przy omawianiu instrukcji CALL, nie wspomniałem
(zresztą specjalnie) jak wywoływać funkcje (lub procedury) z
parametrami. Teraz napiszę o wszystkim, co jest związane z
obsługą funkcji we wstawkach.

a) Wywoływanie funkcji / procedur z parametrem.

Ogólnie argumenty funkcją i procedurą podaje się poprzez
położenie ich na stos. Pierwsza położona na stos wartość zostaje
przypisana pierwszemu argumentowi. Czasem jednak jest
odwrotnie (tak jak w C++), w dużej mierze zależy to od
implementacji. Jednak gdy kompilator jest 100% zgodny ze
standardem, to kolejność jest taka, jaką podałem na początku
(np.: Borland Turbo Pascal).

b) Odbieranie wyniku funkcji

Jeżeli jeszcze nie wiesz dobrze jak zwracać wynik z funkcji, to przypomnij sobie to. Odebranie wyniku funkcji polega na
odwróceniu poprzedniego procesu ;)

Pisząc kod wywołujący funkcję trzeba znać typ, jaki ona zwraca i
gdzie go zwraca (patrz 3.b ). Nie ma tu wiele do wyjaśniania -
popatrzmy więc na przykład.

asm
push 1000d {pierwszy argument 'a'}
push 2000d {drugi argument 'b'}
call dodaj {wywołanie naszej funkcji 'dodaj'}
mov c, ax {odebranie wyniku do zmiennej 'c'}
end;
writeln( c );

5. Instrukcje 32-bitowe.

Stare wersje Turbo Pascala, jak i innych kompilatorów, nie
pozwalają na używanie najnowszych instrukcji procesorów
(np.: MMX, itp). Większość implementacji nie "zna" nawet
wszystkich instrukcji procesorów z rodziny 30486.

Najprościej jest załatwić sobie nowy kompilator lub uaktualnienia.
Jednak nie zawsze można, np. gdy chcemy zachować zgodność z poprzednimi wersjami? Właśnie tym teraz się zajmiemy.

Dla rozwiania wątpliwości, nawet jeśli zakodujemy pewną
instrukcję dostępną dopiero od procesora np.: Pentium, to na wcześniejszych procesorach program najprawdopodobniej się
zawiesi lub wykona parę innych instrukcji, gdy procesor jej nie zna.

a) Pisanie i wykorzystanie instrukcji 32-bitowych.

Przyjrzyjmy się przykładowej procedurze Pascala.

Procedure ClearSeg(Color:byte;var MSeg); Assembler;
Asm
mov AX, word ptr [MSeg+2]
mov ES, AX
mov Al, Color
mov ah, al
mov bx, ax
db 66h
shl ax, 16 {shl eax, 16}
mov ax, bx
mov DI, 0
mov CX, 16080
db 0F3h, 66h, 0ABh; {Rep Stosd}
end;

Pewnie już zauważyłeś nieznane ci (jeszcze) znaczki wtrącone do
kodu ;) Są to reprezentacje instrukcji w kodzie maszynowym
(rozumianych przez człowieka). 'DB' oznacza jeden bajt. Można
także wykorzystywać 'DW', 'DD', itd. Jednak gdy używany danych
większych od 'DB' to trzeba odwracać wartości (co bajt). Sprawa
jeszcze bardziej komplikuje się gdy chcemy użyć danych
większych, np.: 'DD'. Po oznaczeniu wielkości wpisywanych
instrukcji (najlepiej zawsze używaj 'DB') trzeba wypisać kod
instrukcji maszynowych, oddzielonych przecinkami.

'Db 66h' oznacz że w tym miejscu pamięci, między instrukcją
mov bx, ax a shl ax, 16, zostanie umieszczony bajt o wartości 66h. Ten bajt razem z instrukcją shl ax, 16 zostanie przeczytany przez procesor jako shl eax, 16. W tym przypadku wykorzystanie rejestru
EAX przyśpieszyło program - w innym wypadku trzeba by
pisać więcej instrukcji.

Ciąg 'Db 0F3h, 66h, 0Abh' jest instrukcją Rep Stosd, także nie dostępną w większości implementacji, gdyż wykorzystuje rejestr
EAX.

Szczególnie ważne jest wykorzystanie instrukcji 32-bitowych w operacjach na koprocesorze, gdyż tam liczy się czas.

Wcześniej pisałem o odwracaniu kodu, teraz pokażę przykład.

Db 0DAh, 0E9h {fucompp}
Dw 0E9DAh {fucompp}

Oba te zapisy przeczytane zostaną jako instrukcja koprocesora 'fucompp'.

Pisząc w kodzie maszynowym bardzo ważny jest odpowiedni komentarz. Po pewnym czasie zapis 'db 26h, 67h, 66h, 8Bh, 03h' będzie dla nas nic nie znaczącym zapisem, którego NA PEWNO nie będziesz rozumiał!

b) Skąd brać kod maszynowy.

Najpierw co to jest kod maszynowy? Są to instrukcje dla
procesora w postaci kodu binarnego (lub hex'ów jak kto woli).
Zwykły człowiek nie jest w stanie zapamiętać takich rozkazów
(np.: 8CC8h), łatwiej jest zapamiętać mnemoniki (np.: mov ax, cs) wymyślone specjalnie dla nas.

Kod maszynowy możemy łatwo zaczerpnąć z różnych debugerów
(np.: Turbo Debuger ).

Aby to zrobić należy włączamy debugera i wybrać opcje
Assemble... z manu podręcznego. Następnie wpisujemy komendę, której kod chcemy spisać (musi to być w miarę nowy debuger). I spisujemy zwróconą komendę w postaci hex'ów, pojawi się na lewo od
naszej instrukcji (o ile nie wystąpi błąd). Także w różnych książkach można znaleźć kod maszynowy instrukcji.

Gdy potrzebujemy większy kawał kodu, to wpisywanie wszystkich
instrukcji było by co najmniej pracochłonne. W takim wypadku
potrzebujemy kompilatora Assemblera (np.: Turbo Assembler i
Turbo Linkera). Kompilujemy nim tylko nasze instrukcje w
Assemblerze (mogą być wyjęte z kontekstu), najlepiej do postaci
czystego kodu (*.COM). Następnie nasz plik wynikowy otwieramy
programem typu Hex Edit (np.: Hex Workshop) i kopiujemy
wybrany fragment do kodu Pascala. Taki kod maszynowy najlepiej włożyć w klauzurę Inline(). Oczywiście TRZEBA opisać w
komentarzach kod maszynowy, aby go rozumieć po jakimś czasie!