Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00435 007327 10472196 na godz. na dobę w sumie
Praktyczny kurs asemblera - książka
Praktyczny kurs asemblera - książka
Autor: Liczba stron: 384
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-433-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> asembler - programowanie
Porównaj ceny (książka, ebook, audiobook).

Wejdź w świat programowania w języku asemblera

Uważasz, że możliwości języków programowania wysokiego poziomu nie pozwalają na napisanie programu, którego potrzebujesz? Chcesz stworzyć sterownik, program rezydentny, demo lub... wirusa? Interesuje Cię, co dzieje się w komputerze podczas wykonywania programu?

Wykorzystaj potencjał asemblera!

Programowanie w języku niskiego poziomu daje niemal nieograniczoną kontrolę nad sprzętem i działaniem aplikacji. Programy napisane w języku asemblera działają szybko, są niewielkie i zajmują mało pamięci. Są bardzo wydajne i otwierają dostęp do takich obszarów komputera, do których dostęp z poziomu C++ czy Visual Basica jest niemożliwy.

Książka 'Praktyczny kurs asemblera' wprowadzi Cię w świat programowania w tym języku. Dowiesz się, jak działa procesor, w jaki sposób komunikuje się z pamięcią i pozostałymi elementami komputera. Poznasz typy rozkazów procesora, tryby adresowania i zasady tworzenia programów w asemblerze. Lepiej poznasz swój komputer i dowiesz się, w jaki sposób zapamiętuje i przetwarza dane. Komputer przestanie być dla Ciebie 'czarną skrzynką' wykonującą w czarodziejski sposób Twoje polecenia.

Po przeczytaniu tej książki przestaniesz postrzegać asemblera jako zbiór magicznych zaklęć, zrozumiałych jedynie dla brodatych guru pamiętających jeszcze czasy komputerów zajmujących powierzchnię sali gimnastycznej. Napiszesz programy, których uruchomienie nie będzie wymagało od użytkownika posiadania superkomputera. Poznasz wszystkie, nawet najgłębiej ukryte, możliwości komputera.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Praktyczny kurs asemblera Autor: Eugeniusz Wróbel ISBN: 83-7361-433-8 Format: B5, stron: 384 Wejdĥ w ġwiat programowania w jêzyku asemblera • Dowiedz siê, kiedy u¿ycie asemblera jest niezbêdne • Poznaj zasady programowania w asemblerze • Napisz szybkie i wydajne programy dla DOS-a i Windows • Zdob¹dĥ wiedzê o zasadach dzia³ania procesora i pamiêci Uwa¿asz, ¿e mo¿liwoġci jêzyków programowania wysokiego poziomu nie pozwalaj¹ na napisanie programu, którego potrzebujesz? Chcesz stworzyæ sterownik, program rezydentny, demo lub... wirusa? Interesuje Ciê, co dzieje siê w komputerze podczas wykonywania programu? Wykorzystaj potencja³ asemblera! Programowanie w jêzyku niskiego poziomu daje niemal nieograniczon¹ kontrolê nad sprzêtem i dzia³aniem aplikacji. Programy napisane w jêzyku asemblera dzia³aj¹ szybko, s¹ niewielkie i zajmuj¹ ma³o pamiêci. S¹ bardzo wydajne i otwieraj¹ dostêp do takich obszarów komputera, do których dostêp z poziomu C++ czy Visual Basica jest niemo¿liwy. Ksi¹¿ka „Praktyczny kurs asemblera” wprowadzi Ciê w ġwiat programowania w tym jêzyku. Dowiesz siê, jak dzia³a procesor, w jaki sposób komunikuje siê z pamiêci¹ i pozosta³ymi elementami komputera. Poznasz typy rozkazów procesora, tryby adresowania i zasady tworzenia programów w asemblerze. Lepiej poznasz swój komputer i dowiesz siê, w jaki sposób zapamiêtuje i przetwarza dane. Komputer przestanie byæ dla Ciebie „czarn¹ skrzynk¹” wykonuj¹c¹ w czarodziejski sposób Twoje polecenia. • Podstawowe wiadomoġci o architekturze procesorów Intel • Organizacja pamiêci i tryby adresowania • Omówienie listy rozkazów procesora • Narzêdzia do tworzenia programów w jêzyku asemblera • Struktura programu w asemblerze • Definiowanie zmiennych • Tworzenie podprogramów i makrorozkazów • Wykorzystanie funkcji BIOS-a oraz MS-DOS • Programy w asemblerze uruchamiane w systemie Windows • Optymalizacja kodu • Tworzenie modu³ów dla innych jêzyków programowania Spis treści Rozdział 1. Wprowadzenie .................................................................................... 7 1.1. Co to jest asembler? ...................................................a..................................................7 1.2. Dlaczego programować w języku asemblera? ...................................................a........10 1.3. Dlaczego warto poznać język asemblera?...................................................a...............12 1.4. Wymagane umiejętności ...................................................a.........................................12 1.5. Konwencje stosowane w książce ...................................................a............................13 Rozdział 2. Zaczynamy typowo — wiedząc niewiele, uruchamiamy nasz pierwszy program ................................................ 17 2.1. „Hello, world!” pod systemem operacyjnym MS DOS .............................................18 2.2. „Hello, world!” pod systemem operacyjnym Windows.............................................22 Rozdział 3. Wracamy do podstaw — poznajemy minimum wiedzy na temat architektury procesorów 80x86 ......................................... 29 3.1. Rejestry procesora 8086 ...................................................a..........................................30 3.2. Zwiększamy rozmiar rejestrów — od procesora 80386 do Pentium 4 ......................33 3.3. Zwiększamy liczbę rejestrów — od procesora 80486 do Pentium 4 .........................35 3.4. Segmentowa organizacja pamięci ...................................................a...........................39 3.5. Adresowanie argumentów...................................................a.......................................43 3.6. Adresowanie argumentów w pamięci operacyjnej...................................................a..44 Rozdział 4. Poznajemy narzędzia ......................................................................... 47 4.1. Asembler MASM ...................................................a...................................................a.49 4.2. Program konsolidujący — linker ...................................................a............................52 4.3. Programy uruchomieniowe ...................................................a.....................................54 4.4. Wszystkie potrzebne narzędzia razem, czyli środowiska zintegrowane....................62 Rozdział 5. Nadmiar możliwości, z którym trudno sobie poradzić — czyli lista instrukcji procesora....................................................... 67 5.1. Instrukcje ogólne — jednostki stałoprzecinkowej ...................................................a..70 5.2. Koprocesor arytmetyczny — instrukcje jednostki zmiennoprzecinkowej.................73 5.3. Instrukcje rozszerzenia MMX...................................................a.................................75 5.4. Instrukcje rozszerzenia SSE ...................................................a....................................78 5.5. Instrukcje rozszerzenia SSE2 ...................................................a..................................82 5.6. Instrukcje rozszerzenia SSE3 ...................................................a..................................85 5.7. Instrukcje systemowe ...................................................a..............................................85 4 Praktyczny kurs asemblera Rozdział 6. Wracamy do ogólnej struktury programu asemblerowego .................. 87 6.1. Uproszczone dyrektywy definiujące segmenty...................................................a.......87 6.2. Pełne dyrektywy definiowania segmentów...................................................a.............92 6.3. Spróbujmy drobną część tej wiedzy zastosować w prostym programie, a przy okazji poznajmy nowe pomocnicze dyrektywy...................................................a96 Rozdział 7. Ważna rzecz w każdym języku programowania — definiowanie i stosowanie zmiennych ......................................... 105 7.1. Zmienne całkowite ...................................................a................................................106 7.2. Zmienne zmiennoprzecinkowe ...................................................a.............................109 7.3. Definiowanie tablic i łańcuchów...................................................a...........................110 7.4. Struktury zmiennych ...................................................a.............................................114 7.5. Dyrektywa definiująca pola bitowe...................................................a.......................117 Rozdział 8. Podprogramy .................................................................................. 119 8.1. Stos ...................................................a...................................................a.....................119 8.2. Wywołanie i organizacja prostych podprogramów..................................................122 8.3. Poznajemy dyrektywę PROC-ENDP ...................................................a....................123 8.4. Parametry wywołania podprogramu ...................................................a.....................128 8.5. Zmienne lokalne...................................................a...................................................a.137 Rozdział 9. Oddalamy się od asemblera w kierunku języków wyższego poziomu, czyli użycie makroinstrukcji oraz dyrektyw asemblacji warunkowej.... 139 9.1. Makroinstrukcja definiowana...................................................a................................139 9.2. Dyrektywa LOCAL...................................................a...............................................144 9.3. Dyrektywy asemblacji warunkowej ...................................................a......................144 9.4. Makroinstrukcje niedefiniowane...................................................a...........................148 9.5. Makroinstrukcje tekstowe ...................................................a.....................................149 9.6. Makroinstrukcje operujące na łańcuchach (na tekstach)..........................................150 Rozdział 10. Czy obsługę wszystkich urządzeń komputera musimy wykonać sami? Funkcje systemu MS DOS oraz BIOS .............................................. 153 10.1. Co ma prawo przerwać wykonanie naszego programu? ........................................154 10.2. Obsługa klawiatury oraz funkcje grafiki na poziomie BIOS .................................156 10.3. Wywoływanie podprogramów systemu operacyjnego MS DOS...........................163 Rozdział 11. Obalamy mity programując w asemblerze pod systemem operacyjnym Windows............................................. 169 11.1. Systemowe programy biblioteczne ...................................................a.....................170 11.2. Najprawdziwsze pierwsze okno ...................................................a..........................173 11.3. Struktury programowe HLL — to też jest asembler!.............................................178 11.4. Idziemy jeden krok dalej i wykorzystujemy program generatora okien Prostart......180 Rozdział 12. Czy możemy przyśpieszyć działanie naszego programu? Wybrane zagadnienia optymalizacji programu.................................. 189 12.1. Kiedy i co w programie powinniśmy optymalizować?..........................................191 12.2. Optymalizujemy program przygotowany dla procesora Pentium 4.......................193 12.3. Wspieramy proces optymalizacji programem Vtune .............................................200 12.4. Na ile różnych sposobów możemy zakodować kopiowanie tablic?........................201 Rozdział 13. Dzielimy program na moduły i łączymy moduły zakodowane w różnych językach programowania ................................................ 209 13.1. Jak realizować połączenia międzymodułowe?...................................................a....210 13.2. Mieszamy moduły przygotowane w różnych językach .........................................214 Spis treści 5 Rozdział 14. Przykładowe programy (MS DOS) .................................................... 219 14.1. Identyfikujemy procesor ...................................................a.....................................219 14.2. Wchodzimy w świat grafiki — nieco patriotycznie...............................................225 14.3. Program rezydentny, czyli namiastka wielozadaniowości.....................................228 14.4. Pozorujemy głębię...................................................a...............................................233 14.5. Wyższa graficzna szkoła jazdy ze zmiennymi zespolonymi .................................236 Rozdział 15. Przykładowe programy (Windows) .................................................. 243 15.1. Zegarek...................................................a...................................................a.............243 15.2. Dotknięcie grafiki przez duże „G” ...................................................a......................248 15.3. Przekształcamy mapę bitową ...................................................a..............................250 Załącznik 1. Interesujące strony w internecie ..................................................... 271 Załącznik 2. Lista dyrektyw i pseudoinstrukcji języka MASM .............................. 275 Z2.1. Dyrektywy określające listę instrukcji procesora ..................................................275 Z2.2. Organizacja segmentów...................................................a......................................277 Z2.3. Definiowanie stałych oraz dyrektywy związane z nazwami symbolicznymi........279 Z2.4. Definiowanie zmiennych ...................................................a....................................280 Z2.4. Dyrektywy asemblacji warunkowej...................................................a....................282 Z2.5. Makroinstrukcje i dyrektywy nimi związane...................................................a......283 Z2.6. Pseudoinstrukcje typu HLL ...................................................a................................285 Z2.7. Dyrektywy związane z podprogramami ...................................................a.............286 Z2.8. Dyrektywy wpływające na kształt listingu asemblacji ..........................................287 Z2.9. Połączenia międzymodułowe ...................................................a.............................289 Z2.10. Dyrektywy związane z diagnostyką procesu asemblacji .....................................290 Z2.11. Inne dyrektywy i pseudoinstrukcje ...................................................a...................291 Załącznik 3. Operatory stosowane w języku MASM ............................................ 293 Z3.1. Operatory stosowane w wyrażeniach obliczanych w czasie asemblacji ...............293 Z3.2. Operatory stosowane w wyrażeniach obliczanych w czasie wykonywania programu...................................................a..............................297 Załącznik 4. Symbole predefiniowane.................................................................. 299 Załącznik 5. Przegląd instrukcji procesora Pentium 4......................................... 303 Z5.1. Instrukcje ogólne (jednostki stałoprzecinkowej) ...................................................a303 Z5.2. Instrukcje jednostki zmiennoprzecinkowej (koprocesora arytmetycznego)..........309 Z5.3. Instrukcje rozszerzenia MMX ...................................................a............................313 Z5.4. Instrukcje rozszerzenia SSE...................................................a................................315 Z5.5. Instrukcje rozszerzenia SSE2...................................................a..............................319 Z5.6. Instrukcje rozszerzenia SSE3...................................................a..............................323 Z5.7. Instrukcje systemowe...................................................a..........................................325 Załącznik 6. Opis wybranych przerwań systemu BIOS ......................................... 327 Z6.1. Funkcje obsługi klawiatury wywoływane przerwaniem programowym INT 16h ...327 Z6.2. Funkcje obsługi karty graficznej wywoływane przerwaniem programowym INT 10h. ...................................................a......................329 Załącznik 7. Wywołania funkcji systemu operacyjnego MS DOS.......................... 335 Z7.1. Funkcje realizujące odczyt lub zapis znaku z układua wejściowego lub wyjściowego ...................................................a...................................................a.....335 Z7.2. Funkcje operujące na katalogach ...................................................a........................337 Z7.3. Operacje na dysku...................................................a...............................................337 Z7.4. Operacje na plikach (zbiorach) dyskowych...................................................a........339 Z7.5. Operacje na rekordach w pliku ...................................................a...........................341 6 Praktyczny kurs asemblera Z7.6. Zarządzanie pamięcią operacyjną ...................................................a.......................342 Z7.7. Funkcje systemowe...................................................a.............................................342 Z7.8. Sterowanie programem ...................................................a.......................................344 Z7.9. Funkcje związane z czasem i datą ...................................................a........................345 Z7.10 Inne funkcje ...................................................a...................................................a....345 Załącznik 8. Opis wybranych funkcji API ............................................................. 347 Z8.1. CheckDlgButtom ...................................................a................................................347 Z8.2. CloseHandle...................................................a...................................................a.....348 Z8.3 CopyFile.........................................a...................................................a......................349 Z8.4. CreateFile...................................................a...................................................a.........350 Z8.5. CreateWindowEx...................................................a................................................352 Z8.6. DeleteFile...................................................a...................................................a.........355 Z8.7. ExitProcess...................................................a...................................................a.......355 Z8.8. GetFileSize...................................................a...................................................a.......356 Z8.9. MessageBox...................................................a...................................................a.....357 Z8.10. ShowWindow...................................................a...................................................a.359 Załącznik 9. Tablica kodów ASCII oraz kody klawiszy ......................................... 361 Z9.1. Kody ASCII ...................................................a...................................................a.....361 Z9.2. Kody klawiszy ...................................................a...................................................a.361 Załącznik 10. Program Segment Prefix (PSP) ..................................................... 367 Załącznik 11. Płyta CD załączona do książki ...................................................... 369 Skorowidz .......................................................................................................... 371 Rozdział 2. Zaczynamy typowo — wiedząc niewiele, uruchamiamy nasz pierwszy program Każdy szanujący się podręcznik programowania niezależnie od tego, jakiego języka dotyczy, musi rozpocząć się zgodnie z powszechnie szanowaną tradycją: programem wyświetlającym na ekranie monitora komunikat „Hello, world!”. Wprawdzie nie znamy jeszcze ani architektury procesora Pentium, ani też samego języka asemblera i jego skład- ni, to jednak spróbujmy pokazać, jak wyglądałby taki miniprogram, i to zarówno w wersji przeznaczonej do uruchomienia pod systemem operacyjnym MS DOS, jak i pod sys- temem Windows. Tak jak to zostało zasygnalizowane w pierwszym rozdziale, nie bę- dziemy chcieli w naszym pierwszym programie zrobić wszystkiego sami! Skorzystamy w obu przypadkach z podprogramów (biblioteki) systemowych wyświetlania tekstu na ekranie monitora. Tak więc nasz program sprowadzi siuę do:     zadeklarowania, jaki tekst chcemy wyświetlić, przygotowania parametrów wywołania procedury systemouwej, wywołania tejże procedury, zakończenia programu, czyli oddania sterowania systuemowi operacyjnemu. 18 Praktyczny kurs asemblera 2.1. „Hello, world!” pod systemem operacyjnym MS DOS Najprostszy program asemblerowy, który w okienku wirtualnego systemu MS DOS bądź na całym ekranie wyświetli żądany napis, może miueć następującą postać: /ÎLRKGTYU[RTQITCOYCUGODNGTG 5[UVGOQRGTCE[LP[/5 15 OQFGNUOCNNOQFGNRCOKúEKUGIOGPVRTQITCOWYKUGIOGPVFCP[EJ FQUVúRP[DKÎTTQMCÎYRTYQEGUQTC FCVCRQEæVGMUGIOGPVWFCP[EJ VGMUVD[VG*GNNQYQTNFCJFJ UVCEMJUGIOGPVUVQUWQCFGMNCTQYCP[OYTQOKCTG EQFGRQEæVGMUGIOGPVWMQFGORTQYITCOW UVCTVWROCMTQKPUVTWMELCIGPGTWLæECUGMYGPELúY KPKELWLæEæTGLGUVT[UGIYOGPVQYG 5K55 OQXFZQHHUGVVGMUVYRTQYCFGPKGRCTCOGVTÎYY[YQđCPKC OQXCJJRTQEGFWT[Y[ħYKGVNGPKCMQOYWPKMCVW KPVJY[YQđCPKGRTQEGFWT[U[UYVGOQYGL GZKVOCMTQKPUVTWMELCIGPGTWLæECUGYMYGPELúMQēEQYæRTQITCOW GPFMQPKGERTQITCOWļTÎFđQYGIQ Spróbujmy teraz kolejno objaśnić poszczególne linie programu. Od razu można zauwa- żyć szczególną rolę znaku średnika (). Za tym znakiem umieszczać będziemy komen- tarz objaśniający działanie programu, który nie jest analizowany przez asembler. Im więcej będzie tego komentarza i im bardziej będzie wyczerpujący, tym nasz program będzie bardziej zrozumiały dla innych, jak i (po jakimś czasie) dla nas samych. A teraz wyjaśnijmy, co oznaczają poszczególne linie programuu: OQFGNUOCNN Procesor Pentium narzuca pewną specyficzną, segmentowuą organizację pamięci operacyjnej. Dyrektywa OQFGN pozwala w prosty sposób zdefiniować tzw. model pamięci, czyli sposób zorganizowania segmeuntów w naszym programie. Parametr UOCNN informuje, że w naszym programie będziemy mieli do dyspozycji jeden segment z kodem programu oraz jeden segment z danymi.  Ta dyrektywa powoduje, że asembler (program tłumaczącyu) zezwoli na używanie w programie zbioru instrukcji procesorau 80386 (a więc także procesora Pentium). W naszym prostym przykładzie mogliubyśmy pominąć tę dyrektywę, wtedy jednak asembler akceptowałby jedynieu instrukcje procesora 8086. Wpłynęłoby to jedynie na nieco inne przetłumaczenie uobjaśnionej poniżej makroinstrukcji UVCTVWR, jednak bez zmiany jej znaczenia w programie. FCVC Dyrektywa definiująca początek segmentu z danymi. Rozdział 2. ♦ Zaczynamy typowo — wiedząc niewiele, uruchamiamy… 19 VGMUVD[VG*GNNQYQTNFCJFJ Linia programu deklarująca naszą jedyną zmienną, czuyli tekst, jaki chcemy wyświetlić na ekranie. Słowo VGMUV jest zdefiniowaną przez nas nazwą zmiennej tekstowej, z kolei słowo D[VG jest dyrektywą asemblera informującą, że zmienna tekstowa jest w rzeczywistości zmienną buajtową. Każda z liter wyświetlanego tekstu umieszczonego w cudzysłowie zaumieniona zostanie w procesie asemblacji na odpowiadający jej bajt w koudzie ASCII. CJ, FJ to kody ASCII nowej linii oraz powrotu karetki (przesuunięcia kursora do początku linii) wyrażone liczbą szesnastkową. Ponieuważ do wyświetlenia komunikatu na ekranie wykorzystamy procedurę systemuową, łańcuch znaków zakończyć musimy kodem ASCII znaku dolara, co zapisaliśumy: ŒŒ. Brak znaku dolara spowodowałby, że wyświetlane byłyby kolejune bajty z pamięci operacyjnej zawierające przypadkowe wartości. UVCEMJ Dyrektywa kończy segment danych i deklaruje segment ustosu o wielkości 256 bajtów (czyli 100 szesnastkowo). EQFG Dyrektywa definiująca kolejny segment, tym razem z kuodem programu. UVCTVWR Pierwsze instrukcje programu powinny zainicjować odupowiednimi wartościami rejestry, które odpowiadają za rozmieszuczenie segmentów w pamięci operacyjnej. Program musi mieć informację, ujaki jest adres początku segmentu danych i segmentu stosu (adres pouczątku segmentu programu zostanie ustawiony przez system operacyjnyu w czasie ładowania programu do pamięci). Makroinstrukcja predefiniowana UVCTVWR zostanie w czasie asemblacji zamieniona na ciąg instrukcji purocesora wpisujących do rejestrów segmentowych odpowiednie wartości. Będzie ouna równocześnie informacją, gdzie zaczyna się program. Teraz nastąpi główna część programu. Instrukcje OQX, będące jednymi z najczęściej używanych w asemblerze, powodują skopiowanie prawego argumentu w miejsce lewe- go. Będzie to przygotowanie parametrów wywołania podprogramu systemowego, który wywołamy rozkazem KPV. OQXFZQHHUGVVGMUV Rozkaz załaduje do rejestru procesora DX adres początku zmiennej tekstowej o nazwie VGMUV w pamięci operacyjnej. Będzie to adres 16-bitowy (taką wielkość ma rejestr DX) liczony względem początku segumentu danych, nazywany przez niektórych odległością w bajtach od pouczątku segmentu. Adres ten będziemy nazywać krótko angielskim terminemu offset. 1HHUGV to także nazwa operatora, który użyty w omawianej iunstrukcji powoduje wydzielenie z nazwy VGMUV tej części adresu. 20 Praktyczny kurs asemblera OQXCJJ Wszystkie udostępnione programom użytkowym funkcje suystemu operacyjnego MS DOS wywołuje się w identyczny sposób, dluatego ich rozróżnienie następuje przez podanie jej numeru w ruejestrze AH procesora. Procedura wyprowadzająca na ekran monitora tekst, kutórego offset umieszczony jest w rejestrze DX, ma numer 9. KPVJ Instrukcja procesora KPV powoduje wywołanie specyficznego podprogramu, tzw. podprogramu obsługi przerwania (ang. interrupt). System operacyjny MS DOS standardowo wykorzystuje rozkaz KPVJ do wywoływania udostępnionych programom użytkowym funkcji (proceduru) systemowych, rozróżnianych zawartością rejestru AH. GZKV Makroinstrukcja predefiniowana GZKV zostanie w procesie asemblacji zamieniona na następujący ciąg instrukcji procesorau, który powoduje zakończenie programu i oddanie sterowania systemowiu operacyjnemu: OQXCJEJ KPVJ Jak widać, jest to znane nam już wywołanie proceduryu systemowej, tym razem o numerze 4c szesnastkowo. W taki sposób końcuzyć będziemy każdy program asemblerowy uruchamiany pod systemem uMS DOS. GPF Dyrektywa kończąca program źródłowy, wstrzymująca procues asemblacji. Jeżeli w zbiorze z programem źródłowym będą jeszcze jakuieś linie programu, to nie będą one analizowane. Skoro wiemy już, jak wyglądać powinien nasz pierwszy program w asemblerze i co oznaczają poszczególne linie programu źródłowego, to należałoby teraz pokazać, co trzeba zrobić, aby program ten można było uruchomić. W celu maksymalnego uprosz- czenia przyjmijmy, że w wydzielonej kartotece mamy wszystkie niezbędne w tym przy- padku programy (zbiory) tak, jak pokazuje to rysunek u2.1. Rysunek 2.1. Zawartość kartoteki przed asemblacją Rozdział 2. ♦ Zaczynamy typowo — wiedząc niewiele, uruchamiamy… 21 Zbiór o nazwie pierwszy.asm zawiera program źródłowy „Hello, world!”. Wyjaśnijmy rolę pozostałych zbiorów: ML.EXE — program asemblera, pozwalający równocześnie wywołauć program konsolidujący LINK.EXE, ML.ERR — zbiór tekstowy z komunikatami asemblera, LINK.EXE — program konsolidujący (linker), może być wywoływanyu automatycznie przez ML.EXE. Przykładowa sesja wywołania z linii komendy MS DOS programu asemblera i linkera zilustrowana jest na rysunku 2.2. Wyświetlenie zawartości kartoteki pokazuje, że w wyni- ku asemblacji oraz konsolidacji utworzone zostały zbiuory pierwszy.obj oraz pierwszy.exe. Rysunek 2.2. Wywołanie asemblera ML.EXE Na razie nie będziemy zajmować się rozwikłaniem wszystkich komunikatów, które wyświetliły się na ekranie. Ważne jest, że nie pojawił się żaden komunikat o błędzie asemblacji, możemy więc zaryzykować uruchomienie naszego pierwszego programu. Uzyskany efekt ilustruje rysunek 2.3. Rysunek 2.3. Efekt działania programu pierwszy.exe 22 Praktyczny kurs asemblera W linii programu źródłowego może wystąpić:  instrukcja procesora zwana także rozkazem procesoraa (np. MOV, INT),  dyrektywa sterująca pracą asemblera w procesie asemablacji (np. .MODEL, .DATA, .STACK, .CODE, END, .386), lub  makroinstrukcja predefiniowana (np. .STARTUP, .EXIT) lub indywidualnie zdefiniowana przez nas (o czym będzie w następnych rozadziałach) i zamieniona przez asembler na ciąg instrukcji procesora i dyrekatyw asemblera. Funkcje systemu MS DOS udostępnione programom użytkowym wywołuje się roz- kazem INT 21h po wcześniejszym załadowaniu do rejestru AH numeru funkcji. 2.2. „Hello, world!” pod systemem operacyjnym Windows Okienkowa wersja naszego pierwszego (nazwiemy go dla rozróżnienia „drugim”) pro- gramu będzie niestety zupełnie inna. Wynika to z oczywistego faktu, że tak naprawdę to cały program sprowadza się do wywołania podprogramu bibliotecznego i nie ma w nim praktycznie żadnych obliczeń. Skoro system operacyjny jest zupełnie inny, inna jest biblioteka dostępnych funkcji, inna wreszcie jest także organizacja pamięci opera- cyjnej w przypadku pracy procesora w trybie adresacji wirtualnej z ochroną, ponadto system jest wielozadaniowy — zatem nasz program będzie musiał dostosować się do wszelkich wynikających z tego wymogów. Hasło „Hello, world!” wyświetlimy w od- rębnym oknie (a ściślej w małym okienku z komunikatem) wykorzystując do tego funk- cję API (ang. The Microsoft® Win32® Application Programming Interface). API sta- nowi zbiór dynamicznych bibliotek (DLL), z którego korzystają wszystkie procesy uruchamiane w systemie Windows. Więcej na ten temat — w jednym z dalszych roz- działów książki, teraz wystarczy wiedzieć, że aby skorzystać ze wspomnianych funk- cji API, należy do programu źródłowego dołączyć odpowiednie biblioteki oraz zbiory z deklaracjami tzw. prototypów. Program mógłby1 wyglądać następująco: /ÎLFTWIKRTQITCOYCUGODNGTGCRKGTYU[RQFU[UVGOGOQRGTCE[LP[O9KPFQYU  OQFGNHNCVUVFECNNRđCUMKOQFGNRCOKúEK QRVKQPECUGOCRPQPGOCđGKFWľGNKVGT[TQTÎľPKCPG FQđæEGPKGDKQTÎYFGMNCTCELCOKRTQVQV[RÎYKU[ODYQNKGYPúVTP[EJ KPENWFGYKPFQYUKPE KPENWFGWUGTKPE KPENWFGMGTPGNKPE FQđæEGPKGDKQTÎYDKDNKQVGEP[EJ KPENWFGNKDWUGTNKD KPENWFGNKDMGTPGNNKD 1 Podkreślam słowo „mógłby wyglądać”, bowiem podobniem jak w innych językach programowania każdy problem można rozwiązać na wiele sposobów. Rozdział 2. ♦ Zaczynamy typowo — wiedząc niewiele, uruchamiamy… 23 FCVC 6[VWNAQMPCD[VG/ÎLFTWIKRTQITCO 6GMUVAYAQMPKGD[VG*GNNQYQTNF EQFG UVCTV KPXQMG/GUUCIG$QZ07..# 46GMUVAYAQMPKG# 46[VWNAQMPC/$A1- KPXQMG ZKV2TQEGUU07.. GPFUVCTV Podobnie jak poprzednio, wyjaśnimy teraz znaczenie poszczególnych linii programu źródłowego, który — co widać na pierwszy rzut oka — kojarzy się raczej z programem w języku wyższego poziomu niż językiem asemblera, bowiem nie występują w nim wprost żadne instrukcje procesora. Wspominałem już, że wynika to z braku w programie jakichkolwiek obliczeń. Program sprowadza się do wywołania dwóch podprogramów bibliotecznych:   MessageBox — wyświetlenia komunikatu, oraz ExitProcess — zakończenia programu.  Podobnie jak w programie DOS-owym, dyrektywa ta powodujue możliwość używania w programie zbioru instrukcji procesora 80386. Nie jest przypadkiem, że tym razem dyrektywa ta jest pierwszą w programieu. Ze względu na inny model pamięci, zadeklarowany w następnej linii proguramu źródłowego, taką kolejność dyrektyw będziemy zawsze stosować na poczuątku programu, który ma być uruchomiony pod systemem Windows. OQFGNHNCVUVFECNN Procesor Pentium z systemem operacyjnym Windows pracuuje z tzw. płaskim modelem pamięci (ang. flat). Jest to szczególny przypadek modelu segmentowego, dostępny w trybie adresacji wirtualnej z ochroną. Z kolei drugi parametr UVFECNNokreśla, w jakiej kolejności parametry wywołania pruocedur bibliotecznych w naszym programie przekazywane będą na stos i w jaki sposób stos będzie opróżniany z tych parametrów. Nie wnikając na tym etapie rozważań w większe szczegóły, zapamiętamy, że taka linia proguramu będzie się musiała zawsze znaleźć na drugim miejscu po dyrektywie wyboruu procesora. QRVKQPECUGOCRPQPG Dyrektywa powoduje, że w nazwach symbolicznych rozróżuniane będą małe i duże litery. Dyrektywa jest niezbędna, aby mogło sięu odbyć prawidłowe dołączenie procedur bibliotecznych API. KPENWFG Następujące po sobie trzy linie programu z dyrektywąu KPENWFG powodują dołączenie do naszego programu źródłowego zbiorów o nazuwach odpowiednio: windows.inc, user32.inc oraz kernel32.inc. W zbiorach tych znajdują się (w postaci kodów źródłowych) definicje tzw. prototypów pruocedur 24 Praktyczny kurs asemblera bibliotecznych i nazw symbolicznych2, które możemy dołączać do programu użytkowego. Brak tych prototypów i definicji spowodowuałby, że użyte w programie nazwy wywoływanych procedur i niektórychu stałych uznane byłyby jako niezdefiniowane i w konsekwencji program wuynikowy nie mógłby zostać wygenerowany. KPENWFGNKD Dwie linie programu z dyrektywą KPENWFGNKD informują program konsolidujący LINK.EXE, jakie moduły biblioteczne powinien dołączyć w procesuie konsolidacji, czyli generowaniu zbioru drugi.exe. FCVC Dyrektywa definiująca początek segmentu danych, w zwuiązku z płaskim modelem pamięci nazywanym w tym przypadku przez nieuktórych sekcją z danymi. Podobnie jak w przypadku programu uruchamiaunego pod systemem operacyjnym MS DOS, następne linie programu to deklaraucje zmiennych tekstowych. 6[VWNAQMPCD[VG/ÎLFTWIKRTQITCO 6GMUVAYAQMPKGD[VG*GNNQYQTNF Dwie dyrektywy D[VG definiują dwie zmienne tekstowe zainicjowanymi napisami, z których jeden pokaże się na ramce okienuka, drugi zaś — jako właściwy komunikat — wewnątrz. Podprogram biblioteczny,u który wykorzystamy do wyświetlenia napisu, wymaga, aby teukst kończył się bajtem o wartości zero (podobnie jak w przypadku funkcji sysutemu MS DOS znakiem dolara). EQFG Początek segmentu (sekcji) z kodem programu. UVCTV Etykieta (czyli adres symboliczny) informująca, że w tuym miejscu powinno rozpocząć się wykonywanie programu. Etykieta ta będziue musiała dodatkowo wystąpić jako argument dyrektywy GPF kończącej program źródłowy. KPXQMG/GUUCIG$QZ07..# 46GMUVAYAQMPKG# 46[VWNAQMPC/$A1- Dyrektywa KPXQMG pozwala wywołać procedurę /GUUCIG$QZ — przesyła ona na stos parametry wywołania i wyświetla komunikat. Paurametrami wywołania są w tym przypadku kolejno: 07.. „uchwyt” do okna3, w naszym przypadku niepotrzebny i równy zero, # 46GMUVAYAQMPKG adres początku komunikatu, jaki ma być wyświetlonyu, 2 3 Użyliśmy dwóch takich niezdefiniowanych bezpośrednio wm naszym programie nazw: 07.. i /$A1-. Pojęcie „uchwyt” związane jest z programowaniem pod smystemem operacyjnym Windows i jest niezależne od języka programowania. Rozdział 2. ♦ Zaczynamy typowo — wiedząc niewiele, uruchamiamy… 25 # 46[VWNAQMPC adres początku napisu, jaki ma być na ramce okienkua, /$A1- parametr określający, jakie standardowe przyciski umają być wyświetlone (w naszym przypadku jedynie przycisk „OKu”). Dyrektywa KPXQMG należy do grupy dyrektyw asemblera nawiązujących do konstrukcji typowych dla języków wysokiego pozioumu4. Operator # 4 w polu parametrów wywołania procedury ma w tym przypuadku identyczne znaczenie, jak poznany wcześniej operator QHHUGV w polu argumentu instrukcji procesora. W czasie procesu asemblacji dyrektywa zostuanie zastąpiona następującą prostą sekwencją instrukcji procesora: RWUJ/$A1- RWUJQHHUGV6[VWNAQMPC RWUJQHHUGV6GMUVAYAQMPKG RWUJ07.. ECNN/GUUCIG$QZ Jeżeli w programie źródłowym zamiast dyrektywy KPXQMG napiszemy powyższe instrukcje, końcowy efekt działania programu będzie ocuzywiście dokładnie taki sam. Instrukcje procesora RWUJ przesyłają argumenty instrukcji na szczyt stosu, skąd pobierze go procedura /GUUCIG$QZ. Procedura wywołana zostanie typową instrukcją procesora wywołania podprogramu ECNN. KPXQMG ZKV2TQEGUU07.. Wywołanie procedury kończącej program. W czasie asemblaucji dyrektywa zostanie zastąpiona następującą sekwencją instrukcjui: RWUJ07.. ECNN ZKV2TQEGUU Skoro wiemy już, jak powinien wyglądać najprostszy program pracujący pod kontrolą systemu Windows, to spróbujmy go uruchomić. Podobnie jak w przypadku poprzednie- go programu uruchomionego pod systemem MS DOS, umieścimy dla prostoty wszystkie niezbędne zbiory w jednej kartotece, tak jak to pokauzuje rysunek 2.4. Rysunek 2.4. Zawartość kartoteki przed asemblacją 4 Czasem nieco tylko złośliwie mówię, że tego typu dyrektywy oddalają język asemblera od prawdziwego asemblera… 26 Praktyczny kurs asemblera Oprócz zbioru z programem źródłowym drugi.asm, programami asemblera ML.EXE, ML.ERR oraz programu konsolidatora LINK.EXE, w kartotece znajdujemy niezbędne dla prawidłowej asemblacji zbiory biblioteczne typu .LIB oraz dołączane do programu źródłowego zbiory typu .INC zawierające wspomniane definicje prototypów i symboli. Aby prawidłowo przeprowadzić proces asemblacji i konsolidacji, musimy wywołać program asemblera ML.EXE z przełącznikami, które pozwolą wygenerować zbiory drugi.obj oraz drugi.exe w postaci akceptowanej przez program LINK.EXE oraz sys- tem operacyjny Windows. Ilustruje to rysunek 2.5. Rysunek 2.5. Wywołanie asemblera z przełącznikami pozwalającymi wygenerować program pod system operacyjny Windows Uważny Czytelnik zauważył zapewne, że użyliśmy tutaj dokładnie tego samego pro- gramu asemblera, co w poprzednim przykładzie dla systemu MS DOS. Musieliśmy jednak zastosować inny program konsolidatora LINK.EXE, który uwzględnia fakt innej niż w poprzednim przypadku organizacji pamięci operacyjnej. Poszczególne przełącz- niki w naszym przykładzie mają następujące znaczeniue: /coff  Zbiór drugi.obj wygenerowany zostanie w formacie Common Object File Format /link  Kolejne przełączniki dotyczyć będą programu konsoliudatora /subsystem:windows  Program wykonalny będzie uruchamiany pod systemem operacyjnym Windows Po sprawdzeniu, że zbiory drugi.obj i drugi.exe zostały rzeczywiście utworzone, możemy uruchomić nasz program. Rysunek 2.6 pokazuje uzyskany rezultat. Program możemy uruchomić zarówno z linii komendy systemu MS DOS, jak i klikając myszą odpowied- nią ikonę w okienku menedżera plików. Warto (tak przy okazji) zwrócić uwagę na wielkość zbioru drugi.exe i porównać go z uruchomionym wcześniej pierwszy.exe. Rysunek 2.6. Efekt wykonania programu drugi.exe Rozdział 2. ♦ Zaczynamy typowo — wiedząc niewiele, uruchamiamy… 27 Program asemblerowy, który ma być uruchomiony pod systemem operacyjnym Win- dows, może korzystać z programów bibliotecznych API, podobnie jak programy pisane w innych językach programowania. Program asemblera generujący zbiór typu .obj nie różni się w tym przypadku od asemblera używanego w przypadku programu uru- chamianego pod systemem MS DOS, choć inne nieco jest jego wywołanie. Inny natomiast musi być zastosowany program konsolidatora, który uwzględnia specy- fikę stosowanego po systemem operacyjnym Windows modaelu pamięci. Skoro uruchomiliśmy już dwa pierwsze proste programy, to przed próbą zaprojektowa- nia nieco bardziej złożonych programów musimy wrócić do podstaw i w minimalnej dawce — niezbędnej programiście — omówić architekturę procesora, jego listę instruk- cji oraz tryby adresowania argumentów.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Praktyczny kurs asemblera
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: