Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00694 010466 11036957 na godz. na dobę w sumie
Asembler. Ćwiczenia praktyczne - książka
Asembler. Ćwiczenia praktyczne - książka
Autor: Liczba stron: 168
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-836-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> asembler - programowanie
Porównaj ceny (książka, ebook, audiobook).
Wydawałoby się, że języki takie jak Java czy C++ całkowicie usunęły asembler w cień. Nie jest to jednak prawda. Fachowcy od asemblera są i będą poszukiwani na rynku pracy. Aplikacje multimedialne, gry, programy działające w czasie rzeczywistym, to tylko niektóre obszary wykorzystania tego języka. Dzięki tej książce i Ty możesz dołączyć do elitarnej grupy programistów, którzy potrafią ze sprzętu wycisnąć wszystkie możliwości i przejąć nad nim pełną kontrolę.

W książce znajdziesz zestaw ćwiczeń z asemblera procesorów rodziny Pentium, napisany przez specjalistów z Politechniki Śląskiej w Gliwicach.

Poznasz:

Książka 'Ćwiczenia praktyczne z asemblera' da Ci dostęp do wszystkich tajemnic komputera PC.
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 Asembler. Æwiczenia praktyczne Autor: Eugeniusz Wróbel ISBN: 83-7197-836-7 Format: B5, stron: 166 Wydawa³oby siê, ¿e takie jêzyki jak Java czy C++ ca³kowicie usunê³y asembler w cieñ. Nie jest to jednak prawda. Fachowcy od asemblera s¹ i bêd¹ poszukiwani na rynku pracy. Aplikacje multimedialne, gry, programy dzia³aj¹ce w czasie rzeczywistym to tylko niektóre obszary wykorzystania tego jêzyka. Dziêki ksi¹¿ce czytelnik mo¿e do³¹czyæ do elitarnej grupy programistów, którzy potrafi¹ wykorzystaæ wszystkie mo¿liwoġci sprzêtu i przej¹æ nad nim pe³n¹ kontrolê. Ksi¹¿ka zawiera zestaw æwiczeñ z asemblera procesora Pentium, opracowany przez specjalistów z Politechniki Ďl¹skiej w Gliwicach. Umo¿liwiaj¹ one czytelnikowi zapoznanie siê z m.in.: • Narzêdziami u¿ywanymi do pisania i uruchamiania programów asemblerowych • List¹ rozkazów procesora Pentium oraz sposobami adresowania argumentów • Dyrektywami jêzyka MASM • Sposobami pisania podprogramów i makroinstrukcji • Metodami obs³ugi przerwañ i pisania programów rezydentnych • Sposobami optymalizacji kodu Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Rozdział 1. Wprowadzenie ............................................................................................................................................. 5 Rozdział 2. Narzędzia......................................................................................................................................................... 9 2.1. Gdzie i w jakiej formie dostępny jest program asemblera ...................................................w.9 2.2. Inne narzędzia niezbędne, aby uruchomić pierwszy program w asemblerze......................10 Rozdział 3. Asembler, czyli język zorientowany maszynowo..................................................................... 13 3.1. Znajomość procesora. Skąd czerpać niezbędną wiedzę o procesorze?...............................14 3.2. Podstawowe informacje, potrzebne programiście...................................................w............15 Podstawowe rejestry procesora...................................................w....................................15 Rejestry koprocesora arytmetycznego ...................................................w.........................17 Rejestry rozszerzenia MMX ...................................................w........................................19 Rejestry rozszerzenia SSE oraz SSE2...................................................w..........................20 3.3. Skąd czerpać wiedzę na temat asemblera?...................................................w.......................21 Rozdział 4. Przykłady użycia rozkazów procesora..........................................................................................25 4.1. Rozkazy procesora głównego...................................................w...........................................26 Rozkazy przesłań ...................................................w...................................................w......26 Rozkazy arytmetyczno-logiczne ...................................................w..................................28 Rozkazy sterujące wykonaniem programu ...................................................w..................32 Rozkazy wejścia-wyjścia ...................................................w.............................................34 4.2. Sposoby adresowania argumentów ...................................................w..................................34 Tryby adresacji procesora 8086 ...................................................w...................................34 Adres efektywny ...................................................w...................................................w.......36 Tryby adresacji procesorów 80x86 ...................................................w..............................36 4.3. Rozkazy koprocesora arytmetycznego...................................................w.............................41 4.4. Rozkazy rozszerzenia MMX ...................................................w............................................46 Rozdział 5. Podstawowa struktura programu asemblerowego.............................................................. 57 5.1. Podział programu na segmenty ...................................................w........................................57 5.2. Technika podprogramów...................................................w..................................................66 Dyrektywa definiująca podprogram ...................................................w............................67 Przekazywanie parametrów do podprogramu...................................................w..............68 Zmienne lokalne...................................................w...................................................w........71 4 Asembler. Ćwiczenia praktyczne 5.3. Technika makroinstrukcji...................................................w.................................................73 Makroinstrukcje tekstowe ...................................................w............................................74 Makroinstrukcje definiowane ...................................................w......................................74 Bloki iteracyjne ...................................................w...................................................w.........78 Biblioteki makroinstrukcji ...................................................w...........................................80 5.4. Wpływ systemu operacyjnego ...................................................w.........................................86 Rozdział 6. Uruchamianie prostych programów............................................................................................. 91 6.1. Programy typu .COM oraz .EXE ...................................................w.....................................91 6.2. Wykorzystanie podprogramów systemowych ...................................................w.................97 6.3. Parametry wywołania programu ...................................................w....................................102 6.4. Obsługa przerwań priorytetowych ...................................................w.................................105 6.5. Programy rezydentne...................................................w...................................................w. ..111 6.6. Programy biblioteczne...................................................w....................................................117 Rozdział 7. Problemy optymalizacji kodu programu .................................................................................. 121 7.1. Dobór algorytmu ...................................................w...................................................w..... 7.2. Wybrane zagadnienia optymalizacji ...................................................w..............................130 Właściwy dobór rozkazów procesora ...................................................w........................130 Unikanie rozgałęzień ...................................................w.................................................133 Rozmieszczenie struktur danych w pamięci operacyjnej .............................................136 ....125 Rozdział 8. Przykłady prostych programów.....................................................................................................143 8.1. Przeglądanie zawartości katalogów ...................................................w...............................143 8.2. Identyfikacja procesora ...................................................w..................................................154 Rozdział 3. Asembler, czyli język zorientowany maszynowo Jak już wspomniano w rozdziale pierwszym, asembler jest językiem zorientowanym maszynowo i dlatego: (cid:1) Program przygotowany dla określonego procesora nie pmoże być wykonany przez inne procesory. W przypadku procesorów serii 80x86 firmy pIntel program napisany dla procesorów starszych typów będzie mógł być wykonywpany przez procesory nowsze, zachowana jest bowiem (zwana tak w informatycpznym żargonie) „kompatybilność” kolejnych procesorów1. (cid:1) Aby programować w asemblerze, trzeba znać podstawowpą architekturę procesora, w szczególności dostępne programowo rejestry oraz oprganizację pamięci operacyjnej. (cid:1) Aby dobrze programować w asemblerze, należy poznać wewnętrznąp organizację procesora, pamięci podręcznej, mikroarchitekturę ukpładów dekodujących rozkazy oraz układów wykonawczych i wiele innych niełatwych i pczasem trudno dostępnych w literaturze informacji o sposobie wykonywania pospzczególnych rozkazów procesora. 1 Przy pewnych założeniach, np. że nieistotny jest czcas wykonania programu. 14 Asembler. Ćwiczenia praktyczne 3.1. Znajomość procesora. Skąd czerpać niezbędną wiedzę o procesorze? Opis procesorów 80x86 znajdzie Czytelnik w wielu pozycjach literatury, a także w do- stępnej na stronach internetowych w postaci plików w formacie PDF dokumentacji fir- my Intel2. Z tego też powodu w niniejszym rozdziale ograniczymy się jedynie do przy- pomnienia najważniejszych informacji niezbędnych do zrozumienia przykładowych ćwiczeń przedstawionych Czytelnikowi w następnych rozdziałach. Rozpoczniemy od zebrania w tabeli 3.1 niektórych parametrów najważniejpszych procesorów serii 80x86. Tabela 3.1. Wybrane parametry procesorów 80x86 Procesor Data wprowadzenia Mikro- architektura Pierwotna częstotliwość zegara Rozmiar dostępnych rejestrów (w bitach) Przestrzeń adresowa pamięci Pamięć podręczna 8086 Intel 286 1978 1982 Intel 386 DX 1985 Intel 486 DX 1989 Pentium 1993 Pentium Pro 1995 Pentium II 1997 Pentium III 1999 Pentium 4 2000 8 MHz 12,5 MHz 20 MHz 25 MHz 60 MHz 200 MHz 266 MHz 700 MHz P5 P6 P6 P6 Intel NetBurst micro- architecture 1,4 GHz 16 16 32 GP: 32 FPU: 80 GP: 32 FPU: 80 GP: 32 FPU: 80 GP: 32 FPU: 80 MMX: 64 GP: 32 FPU: 80 MMX: 64 XMM: 128 GP: 32 FPU: 80 MMX: 64 XMM: 128 1 MB 16 MB 4 GB — — — 4 GB 8 KB L1 4 GB 16 KB L1 64 GB 64 GB 64 GB 64 GB 16 KB L1 512 KB L2 16 KB L1 512 KB L2 16 KB L1 256 lub 512 KB L2 12 KB µop Execution Trace Cache 8 KB L1 256 KB L2 2 Nie sposób wyobrazić sobie tworzenia programów asemblerowcych bez możliwości ciągłego odwoływania się w czasie pracy do pozycji [10], [11], [12], podanych wc bibliografii. Dokumentacja jest udostępniona przez firmę Intel i uaktualniana w miarę pojawiania się cnowych procesorów. Rozdział 3. (cid:1) Asembler, czyli język zorientowany maszynowo 15 Znajomość rodzaju mikroarchitektury, jak i wielkości oraz organizacji pamięci pod- ręcznej potrzebna nam będzie dopiero w przypadku, gdy zaczniemy myśleć o optymali- zowaniu naszego programu po względem czasu jego wykonania. Jest to bez wątpienia wyższa szkoła jazdy, o którą delikatnie „otrzemy się”, wykonując ćwiczenia w roz- dziale 7. Teraz skupimy się na dostępnych programowo rejestrach procesora Pentium, z których korzystać będziemy, programując w asemblerzpe. 3.2. Podstawowe informacje, potrzebne programiście Rejestry procesora Pentium pozwalają na zapamiętywanie przetwarzanych danych, słu- żą do sterowania pracą procesora, w tym generowania adresu efektywnego argumentów w pamięci operacyjnej. Warto wiedzieć, iż zestaw podstawowych 32-bitowych reje- strów w procesorze Pentium nawiązuje do 8-bitowych mikroprocesorów firmy Intel — procesorów 8080 oraz 8085, które przed wielu laty zrewolucjonizowały technikę kom- puterową i pozwoliły „wyjść” komputerom z niedostępnych, tajemniczych i klimatyzo- wanych hal komputerowych (koniecznie o podwójnych podłogach) na biurko zwykłego śmiertelnika. Sam Intel przyznaje [10], że w procesorze Pentium dopatrzyć można się jeszcze wcześniejszego protoplasty — 4-bitowego pierwszego mikroprocesora 4004 firmy Intel, zaprojektowanego w 1969 roku… Dla nas istotne jest, że 32-bitowa architektura współczesnych procesorów Pentium, zwana IA-32, zawiera w sobie zarówno procesory 32-bitowe (Intel 386, 486, Pentium), jak i wcześniejsze 16-bitowe (8086, Intel 286). Podstawowe rejestry procesora Zaliczymy do nich: (cid:1) osiem rejestrów ogólnego przeznaczenia, (cid:1) sześć rejestrów segmentów (zwyczajowo nazywanych segmpentowymi), (cid:1) rejestr znaczników EFLAGS, (cid:1) wskaźnik rozkazów EIP. 32-bitowe rejestry ogólnego przeznaczenia EAX, EBX, ECX, EDX, EBP, ESI, EDI oraz ESP, pokazane na rysunku 3.1, służą do operowania na argumentach operacji arytmetycznych i logicznych, argumentach służących do obliczania adresu efektywnego oraz na wskaźnikach pamięci. Szczególną rolę pełni rejestr ESP, który jest wskaźnikiem szczytu stosu. 16 Rysunek 3.1. Podstawowe rejestry procesora Pentium Asembler. Ćwiczenia praktyczne Młodsze 16 bitów tych ośmiu rejestrów to odpowiedniki rejestrów ogólnego przezna- czenia procesorów 8086 oraz Intel 286, dostępne odpowiednio poprzez nazwy: AX, BX, BC, DX, BP, SI, DI oraz SP. Każdy z dwóch bajtów rejestrów AX, BX, CX oraz DX dostępny jest niezależnie poprzez nazwy: AH, BH, CH, DH (starsze bajty — High) oraz AL, BL, CL, DL (młodsze bajty — Low). Te ostatnie cztery rejestry nawiązują bezpośrednio do wspomnianego już procesora 8080. Nazwy rejestrów pochodzą od głównego ich przeznaczenia. I tak: (cid:1) EAX — akumulator, główny rejestr do przechowywania argumpentów oraz wyników obliczeń; (cid:1) EBX — rejestr bazowy, wskaźnik do danych w segmencie, zdpefiniowanym przez rejestr DS; (cid:1) ECX — licznik pętli oraz operacji na łańcuchach; (cid:1) EDX — wskaźnik układów wejścia-wyjścia; (cid:1) ESI — rejestr indeksowy, wskaźnik do danych w segmencie,p zdefiniowanym przez rejestr DS, wskaźnik argumentu źródłowego dla opepracji na łańcuchach; (cid:1) EDI — rejestr indeksowy, wskaźnik do danych w segmencie,p zdefiniowanym przez rejestr ES, wskaźnik argumentu przeznaczenia dlpa operacji na łańcuchach; (cid:1) ESP — wskaźnik stosu w segmencie, zdefiniowanym przez repjestr SS; (cid:1) EBP — rejestr bazowy, wskaźnik do danych w segmencie stopsu, zdefiniowanym przez rejestr SS. W procesorze Pentium, pracującym w trybie 32-bitowym, możliwe jest bardzo elastyczne używanie wymienionych powyżej rejestrów, czasem w inny sposób, aniżeli wynikałoby to z ich nazwy i zastosowania w przypadku pracy w trybie 16-bitowym. Na przykład rejestry indeksowe mogą pełnić rolę rejestrów bazowych i odwrotnie, rolę rejestrów in- deksowych lub bazowych pełnić mogą także pozostałe repjestry 32-bitowe. Kolejną grupę rejestrów stanowią 16-bitowe rejestry segmentowe: CS, DS, SS, ES, FS, GS. Rejestry te odgrywają istotną rolę w organizacji pamięci operacyjnej. W przypadku pracy procesora w trybie adresacji rzeczywistej rejestry segmentowe zawierają 16 starszych bitów 20-bitowego adresu początku segmentów. W trybie adpresacji wirtualnej z ochroną rejestry zawierają selektory segmentów, czyli informacje, które w sposób nieco bardziej złożony niż w trybie adresacji rzeczywistej pozwalają zdefiniować segmenty w pamięci operacyjnej. Ponieważ w książce, którą Czytelnik ma w ręce, nie będziemy zajmować się konstrukcją systemów operacyjnych, a ćwiczenia ograniczymy zasadniczo do przy- kładów programów pracujących w trybie adresacji rzeczywistej, zagadnienia selektorów nie będziemy tutaj bardziej szczegółowo opisywać. Rozdział 3. (cid:1) Asembler, czyli język zorientowany maszynowo 17 Poszczególne rejestry definiują (rysunek 3.2): (cid:1) CS — segment programu; (cid:1) SS — segment stosu; (cid:1) DS — podstawowy segment danych; (cid:1) ES, FS, GS — dodatkowe segmenty danych. Rysunek 3.2. Rejestry segmentowe Kolejny rejestr tej grupy to 32-bitowy rejestr EFLAGS, który zawiera następujące znaczniki3: (cid:1) stanu, określające stan procesora po wykonaniu operpacji arytmetycznej bądź logicznej, (cid:1) sterujące, pozwalające wprowadzić procesor w określopny stan, (cid:1) systemowe. Rysunek 3.3, zaczerpnięty z [10], przedstawia rozmieszczenie w rejestrze EFLAGS po- szczególnych znaczników. Warto zauważyć, że młodsze 16 bitów tego rejestru to rejestr znaczników FLAGS procesora Intel 286, zaś najmłodszy bajt zawiera znaczniki znane już ze wspomnianego procesora 8080. Ostatnim rejestrem tej grupy jest 32-bitowy wskaźnik rozkazów EIP (zawierający w so- bie 16-bitowy wskaźnik IP procesorów 8086 i 80286). Rejestr ten wskazuje adres względem początku segmentu programu, skąd pobierany będzie kolejny bajt rozkazu. Rejestr EIP (IP) przeładowywany jest w momencie przekazywania sterowania do inne- go miejsca w programie, czyli w momencie wykonywanipa skoku. Jego zawartość będzie dla nas interesująca głównie w czasie śledzenia wykonywania programu przy użyciu debugera. Rejestry koprocesora arytmetycznego Architektura procesorów 8086, Intel 206 oraz Intel 386 pozwalała na współpracę z mak- symalnie ośmioma koprocesorami, które w znacznym stopniu mogły pracować równo- legle z procesorem głównym. Największe zastosowanie miał koprocesor arytmetyczny, oznaczony odpowiednio jako 8087, 80287 oraz 80387. Począwszy od procesora Intel 486 koprocesor arytmetyczny stał się integralną częścią procesora głównego (zatem nie występuje już jako odrębny układ scalony). Z punktu widzenia programisty fakt ten nie 3 Nazywane przez niektórych programistów żargonowo „flagacmi”. 18 Rysunek 3.3. Rozmieszczenie znaczników stanu i znaczników sterujących w rejestrze EFLAGS Asembler. Ćwiczenia praktyczne ma istotnego znaczenia, bowiem architektura tej części procesora Pentium, która reali- zuje funkcje koprocesora arytmetycznego występującego dawniej jako oddzielny układ scalony, widziana jest przez programistę tak samo jak dawniej — praktycznie bez zmian. Koprocesor arytmetyczny pozwala wykonywać operacje na liczbach zmienno- przecinkowych. Wykorzystywane są tutaj nowe, 80-bitowe rejestry, zorganizowane w 8-elementowy stos (rysunek 3.4). Rysunek 3.4. Rejestry danych koprocesora arytmetycznego W programie używać będziemy następujących nazw tych rpejestrów: (cid:1) ST lub ST(0) — jeden z rejestrów R0-R7, aktualnie wskazywany przez 3-pbitowy wskaźnik szczytu stosu, znajdujący się w rejestrze spterującym koprocesora; (cid:1) ST(1), ..., ST(7) — kolejne rejestry stosu, liczone od aktualnego repjestru ST(0). Rozdział 3. (cid:1) Asembler, czyli język zorientowany maszynowo 19 Zależności między rejestrami R0 – R7 a rejestrami ST, które stosujemy w programie, ilustruje rysunek 3.5. Rysunek 3.5. Rejestry koprocesora, traktowane jako stos Pewna liczba rozkazów operujących na rejestrach koprocesora arytmetycznego powo- duje automatyczne zwiększenie wskaźnika stosu o 1 lub 2. Stos „zawija się”, tzn. na powyższym rysunku rejestr R7 w naszym programie będzie występował jako ST(4), natomiast R0 jako ST(5). Rejestry rozszerzenia MMX Rozszerzenie MMX pozwoliło zwiększyć możliwości procesora Pentium w zakresie przetwarzania obrazu oraz dźwięku. Jest to klasyczny przykład tzw. architektury SIMD (Single Instruction Multiple Data Execution Mode). Programista otrzymuje do dyspozy- cji dodatkowych 8 rejestrów 64-bitowych, nazywanych MM0, …, MM7 oraz nowe typy danych 64-bitowych (por. rysunek 3.6): (cid:1) 8 spakowanych bajtów, (cid:1) 4 spakowane słowa 16-bitowe, (cid:1) 2 spakowane podwójne słowa 32-bitowe, (cid:1) 1 słowo 64-bitowe. Rysunek 3.6. Rejestry rozszerzenia MMX Słowo „spakowane” należy w tym miejscy rozumieć jako umieszczone obok siebie w jednej, 64-bitowej danej. Możliwe jest równoległe wykonywanie operacji arytmetycznych na całych danych 64- bitowych, traktowanych odpowiednio jako bajty, słowa bądź podwójne słowa. Przykła- dowo ilustruje to rysunek 3.7. 20 Rysunek 3.7. Typowa operacja, wykonywana na rejestrach MMX Asembler. Ćwiczenia praktyczne Należy pamiętać, że w rzeczywistości rejestry MMX są „mapowane” na rejestrach ko- procesora arytmetycznego i dlatego nie jest możliwe mieszanie rozkazów, wykorzystu- jących koprocesor arytmetyczny oraz wykorzystujących technologię MMX. Ilustruje to rysunek 3.8, zaczerpnięty z [12]. Rysunek 3.8. Odwzorowanie rejestrów MMX na rejestrach koprocesora arytmetycznego Rejestry MMX w przeciwieństwie do rejestrów koprocesora dostępne są wprost po- przez swoje nazwy: MM0, MM1, …, MM7. Rejestry rozszerzenia SSE oraz SSE2 Rozszerzenie SSE, jakie pojawiło się z chwilą wprowadzenia procesora Pentium III oraz jego dalsze rozwinięcie w Pentium 4, występujące pod nazwą SSE2, jest w pew- nym stopniu połączeniem idei koprocesora arytmetycznego, operującego na liczbach zmiennoprzecinkowych, oraz rozszerzenia MMX, które pozwala równolegle (równo- cześnie) przetwarzać kilka danych, spakowanych w jedpnej danej. Programista otrzymuje do dyspozycji osiem nowych rejestrów 128-bitowych, dostępnych bezpośrednio po- przez nazwy XMM0, XMM1, …, XMM7 (por. rysunek 3.9). Rozdział 3. (cid:1) Asembler, czyli język zorientowany maszynowo 21 Rysunek 3.9. 128-bitowe rejestry rozszerzenia SSE oraz SSE2 Rozszerzenie SSE wprowadza nowy format spakowanej 128-bitowej danej, zawierają- cej cztery 32-bitowe liczby zmiennoprzecinkowe pojedynczej precyzji. Rozszerzenie SSE2 rozszerza te możliwości o kolejne formaty. Programista, korzystając z rozkazów operujących na danych typu SSE oraz SSE2, ma w Pentium 4 do dyspozycji następują- ce formaty danych 128-bitowych: 1. Wartości zmiennoprzecinkowe: (cid:1) 4 wartości zmiennoprzecinkowe pojedynczej precyzji4, (cid:1) 2 wartości zmiennoprzecinkowe podwójnej precyzji. 2. Wartości całkowite: (cid:1) 16 bajtów, (cid:1) 8 słów, (cid:1) 4 podwójne słowa, (cid:1) 2 poczwórne słowa. Na koniec tego pobieżnego przypomnienia elementów architektury, niezbędnego dla zrozumienia ćwiczeń omówionych w kolejnych rozdziałach, zbierzemy na jednym ry- sunku (rysunek 3.10) środowisko, w jakim porusza się programista uruchamiający pro- gram na procesorze Pentium 4. 3.3. Skąd czerpać wiedzę na temat asemblera? Jak już kilkakrotnie wspomniano w tej książce, dostępność literatury na temat języka asemblera procesorów Pentium nie jest zbyt duża. Wystarczy wejść do dowolnej księ- garni technicznej, aby na półkach znaleźć wiele pozycjpi dotyczących baz danych, języka C, Pascala i być może jedną pozycję dotyczącą asemblera. Najczęściej jednak nie znaj- dziemy żadnej pozycji. Sięgnięcie do największych światowych księgarń interneto- wych, takich jak np. www.amazon.com, także nie daje satysfakcjonujących rezultatów. 4 Występuje także w rozszerzeniu SSE. 22 Rysunek 3.10. Podstawowe środowisko programisty w języku asemblera Asembler. Ćwiczenia praktyczne W chwili pisania tych słów jedynymi w miarę aktualnymi pozycjami, dostępnymi na stronach tej księgarni, były książki [7] i [8], które nie są jednak pełnym opisem asem- blera, pozwalają jedynie (trzeba przyznać, że dosyć gruntownie) poznać podstawy tego języka. Pozostaje oczywiście niezawodny Internet, w którym doświadczony internauta znajdzie prawie wszystko. Wiemy już, że aby programować w asemblerze, musimy pznać: (cid:1) architekturę procesora i jego listę rozkazów, a takżpe organizację pamięci operacyjnej — tę wiedzę skutecznie uzyskamy na stronach www.intel.com5, (cid:1) opis języka MASM6, strukturę programu asemblerowego, dyrektywy, pseudoinstrukcje, makroinstrukcje asemblera. 5 Na potrzeby tej książki korzystaliśmy z dokumentacji udocstępnionej na stronach producenta procesorów, w szczególności z pozycji [1], [2], [3], [10], [11] i [12]. Rozdział 3. (cid:1) Asembler, czyli język zorientowany maszynowo 23 Najcenniejszą pozycją drukowaną, opisującą język MASM jest [9] — niestety obecnie praktycznie jest ona nieosiągalna. Niewiele też niestety można znaleźć na stronach www.microsoft.com. Pozostaje szukanie w sieci na stronach przede wszystkim uczelni wyższych, na których prowadzone są wykłady z tego zakresu oraz na stronach różnych pasjonatów asemblera. Na tych ostatnich można znaleźć wiele ciekawych informacji, przykładowych programów, a nawet krótkich kursów programowania w asemblerze. Nie będziemy w tym miejscu podawać konkretnych adresów stron WWW, bowiem ule- gają one zmianom i szybko się dezaktualizują. Warto także śledzić dyskusję na grupach dyskusyjnych, poświęconych asemblerowi pro- cesorów 80x867. 6 W książce opieramy się na języku makroasemblera MASM firmy cMicrosoft. Dla procesorów Pentium dostępne są także inne asemblery, w szczególności TASM firmyc Borland, mający wiele identycznych bądź podobnych do języka MASM elementów oraz NASM — o zupełnie incnej filozofii niż MASM i TASM. Język NASM dostępny jest w Internecie na podobnych zascadach, jak system operacyjny Linux. 7 Dostępne grupy w chwili pisania książki: comp.lang.asm.x86 (angielskojęzyczna), de.comp.lang. assembler.x86 (niemieckojęzyczna).
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Asembler. Ćwiczenia praktyczne
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ą: