Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00456 006291 13846957 na godz. na dobę w sumie
Asembler. Sztuka programowania. Wydanie II - książka
Asembler. Sztuka programowania. Wydanie II - książka
Autor: Liczba stron: 816
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-2854-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> asembler - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj asembler od podstaw i zbuduj fundament
swojej wiedzy o programowaniu

Poznanie asemblera jest jak położenie fundamentu pod budowlę całej twojej wiedzy informatycznej, ponieważ to właśnie ono ułatwia zrozumienie mechanizmów rządzących innymi językami programowania. Język asemblera, należący do języków programowania niższego poziomu, jest powszechnie stosowany do pisania sterowników, emulatorów i gier wideo. Jednak omawiany w tej książce język HLA posiada też wiele cech języków wyższego poziomu, takich jak C, C++ czy Java, dzięki czemu przy jego używaniu nie musisz rezygnować z licznych udogodnień, typowych dla takich języków.

Książka 'Asembler. Sztuka programowania. Wydanie II ' stanowi obszerne i wyczerpujące omówienie języka asemblera. Dzięki wielu jasnym przykładom, pozbawionym niepotrzebnej specjalistycznej terminologii, zawarty tu materiał staje się łatwo przyswajalny dla każdego, kto chciałby poznać programowanie niższego poziomu. Korzystając z tego podręcznika, dowiesz się m.in., jak deklarować i stosować stałe, zmienne skalarne, wskaźniki, tablice, struktury, unie i przestrzenie nazw. Nauczysz się realizować w języku asemblera struktury sterujące przebiegiem wykonania programu. Ponadto drugie wydanie zostało uaktualnione zgodnie ze zmianami, które zaszły w języku HLA. Uwzględnia także stosowanie HLA w kontekście systemów Windows, Linux, Mac OS X i FreeBSD.

Podręcznik na najwyższym poziomie o językach programowania
niższego poziomu.

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

Darmowy fragment publikacji:

Asembler. Sztuka programowania. Wydanie II Autor: Randall Hyde Tłumaczenie: Przemysław Szeremiota ISBN: 978-83-246-2854-4 Tytuł oryginału: The Art of Assembly Language, 2nd edition Format: B5, stron: 816 Poznaj asembler od podstaw i zbuduj fundament swojej wiedzy o programowaniu • Jak pisać, kompilować i uruchamiać programy w języku HLA? • Jak obsługiwać zbiory znaków w bibliotece standardowej HLA? • Jak obliczać wartości wyrażeń logicznych? Poznanie asemblera jest jak położenie fundamentu pod budowlę całej twojej wiedzy informatycznej, ponieważ to właśnie ono ułatwia zrozumienie mechanizmów rządzących innymi językami programowania. Język asemblera, należący do języków programowania niższego poziomu, jest powszechnie stosowany do pisania sterowników, emulatorów i gier wideo. Jednak omawiany w tej książce język HLA posiada też wiele cech języków wyższego poziomu, takich jak C, C++ czy Java, dzięki czemu przy jego używaniu nie musisz rezygnować z licznych udogodnień, typowych dla takich języków. Książka „Asembler. Sztuka programowania. Wydanie II” stanowi obszerne i wyczerpujące omówienie języka asemblera. Dzięki wielu jasnym przykładom, pozbawionym niepotrzebnej specjalistycznej terminologii, zawarty tu materiał staje się łatwo przyswajalny dla każdego, kto chciałby poznać programowanie niższego poziomu. Korzystając z tego podręcznika, dowiesz się m.in., jak deklarować i stosować stałe, zmienne skalarne, wskaźniki, tablice, struktury, unie i przestrzenie nazw. Nauczysz się realizować w języku asemblera struktury sterujące przebiegiem wykonania programu. Ponadto drugie wydanie zostało uaktualnione zgodnie ze zmianami, które zaszły w języku HLA. Uwzględnia także stosowanie HLA w kontekście systemów Windows, Linux, Mac OS X i FreeBSD. • Wstęp do asemblera • Anatomia programu HLA • Reprezentacja danych • Dostęp do pamięci i jej organizacja • Stałe, zmienne i typy danych • Procedury i moduły • Niskopoziomowe struktury sterujące wykonaniem programu • Makrodefinicje i język czasu kompilacji • Manipulowanie bitami • Klasy i obiekty Podręcznik na najwyższym poziomie o językach programowania niższego poziomu Idź do • Spis treści • Przykładowy rozdział Katalog książek • Katalog online • Zamów drukowany katalog Twój koszyk • Dodaj do koszyka Cennik i informacje • Zamów informacje o nowościach • Zamów cennik Czytelnia • Fragmenty książek online Kontakt Helion SA ul. Kościuszki 1c 44-100 Gliwice tel. 32 230 98 63 e-mail: helion@helion.pl © Helion 1991–2010 Spis treĂci PODZI}KOWANIA ................................................................................... 15 1 WST}P DO J}ZYKA ASEMBLEROWEGO .................................................... 17 Anatomia programu HLA ..........................................................................................18 1.1. Uruchamianie pierwszego programu HLA ................................................................20 1.2. 1.3. Podstawowe deklaracje danych programu HLA .......................................................22 1.4. WartoĂci logiczne ......................................................................................................24 1.5. WartoĂci znakowe .....................................................................................................25 Rodzina procesorów 80x86 firmy Intel .....................................................................25 1.6. Podsystem obsïugi pamiÚci .......................................................................................28 1.7. Podstawowe instrukcje maszynowe .........................................................................31 1.8. 1.9. Podstawowe struktury sterujÈce wykonaniem programu HLA ................................34 1.9.1. Wyraĝenia logiczne w instrukcjach HLA .....................................................35 Instrukcje if..then..elseif..else..endif jÚzyka HLA .........................................37 1.9.2. Iloczyn, suma i negacja w wyraĝeniach logicznych ......................................39 1.9.3. 1.9.4. Instrukcja while ...........................................................................................42 Instrukcja for ...............................................................................................43 1.9.5. Instrukcja repeat .........................................................................................44 1.9.6. Instrukcje break oraz breakif ......................................................................45 1.9.7. 1.9.8. Instrukcja forever ........................................................................................45 1.9.9. Instrukcje try, exception oraz endtry ..........................................................46 Biblioteka standardowa jÚzyka HLA — wprowadzenie ............................................50 1.10.1. Staïe predefiniowane w module stdio .........................................................52 1.10.2. Standardowe wejĂcie i wyjĂcie programu ...................................................53 1.10.3. Procedura stdout.newln ..............................................................................54 1.10.4. Procedury stdout.putiN ..............................................................................54 1.10.5. Procedury stdout.putiNSize ........................................................................54 1.10.6. Procedura stdout.put ..................................................................................56 1.10.7. Procedura stdin.getc ...................................................................................58 1.10.8. Procedury stdin.getiN .................................................................................59 1.10.9. Procedury stdin.readLn i stdin.flushInput ....................................................60 1.10.10. Procedura stdin.get .....................................................................................61 1.10. 1.11. Jeszcze o ochronie wykonania kodu w bloku try..endtry ......................................... 62 1.11.1. Zagnieĝdĝone bloki try..endtry .................................................................. 63 1.11.2. Klauzula unprotected bloku try..endtry ...................................................... 65 1.11.3. Klauzula anyexception bloku try..endtry .................................................... 68 1.11.4. Instrukcja try..endtry i rejestry ................................................................... 68 1.12. JÚzyk asemblerowy a jÚzyk HLA ............................................................................... 70 1.13. ½ródïa informacji dodatkowych ............................................................................... 71 2.1. 2.2. 2.3. 2 REPREZENTACJA DANYCH ..................................................................... 73 Systemy liczbowe ..................................................................................................... 74 System dziesiÚtny — przypomnienie .......................................................... 74 2.1.1. 2.1.2. System dwójkowy ...................................................................................... 74 2.1.3. Formaty liczb dwójkowych ........................................................................ 75 System szesnastkowy ............................................................................................... 76 Organizacja danych ................................................................................................... 79 2.3.1. Bity ............................................................................................................. 79 Póïbajty ....................................................................................................... 79 2.3.2. Bajty ............................................................................................................ 80 2.3.3. Sïowa .......................................................................................................... 82 2.3.4. 2.3.5. Podwójne sïowa ......................................................................................... 83 2.3.6. Sïowa poczwórne i dïugie ........................................................................... 84 2.4. Operacje arytmetyczne na liczbach dwójkowych i szesnastkowych ........................ 85 2.5. Jeszcze o liczbach i ich reprezentacji ........................................................................ 86 2.6. Operacje logiczne na bitach ...................................................................................... 88 2.7. Operacje logiczne na liczbach dwójkowych i ciÈgach bitów .................................... 91 2.8. Liczby ze znakiem i bez znaku .................................................................................. 93 2.9. Rozszerzanie znakiem, rozszerzanie zerem, skracanie, przycinanie ........................ 98 2.10. PrzesuniÚcia i obroty .............................................................................................. 102 2.11. Pola bitowe i dane spakowane ............................................................................... 107 2.12. Wprowadzenie do arytmetyki zmiennoprzecinkowej ............................................ 112 2.12.1. Formaty zmiennoprzecinkowe przyjÚte przez IEEE ................................ 116 2.12.2. Obsïuga liczb zmiennoprzecinkowych w jÚzyku HLA .............................. 120 2.13. Reprezentacja liczb BCD ........................................................................................ 124 2.14. Znaki ....................................................................................................................... 125 2.14.1. Zestaw znaków ASCII .............................................................................. 125 2.14.2. Obsïuga znaków ASCII w jÚzyku HLA ..................................................... 129 2.15. Zestaw znaków Unicode ........................................................................................ 134 2.16. ½ródïa informacji dodatkowych ............................................................................. 134 3 DOST}P DO PAMI}CI I JEJ ORGANIZACJA ............................................ 135 Tryby adresowania procesorów 80x86 .................................................................. 136 Adresowanie przez rejestr ....................................................................... 136 3.1.1. 3.1.2. 32-bitowe tryby adresowania procesora 80x86 ....................................... 137 3.1. 6 S p i s t r e Ă c i 3.2. Organizacja pamiÚci fazy wykonania .......................................................................144 3.2.1. Obszar kodu ..............................................................................................145 3.2.2. Obszar zmiennych statycznych .................................................................147 3.2.3. Obszar niemodyfikowalny .........................................................................147 3.2.4. Obszar danych niezainicjalizowanych .......................................................148 Atrybut @nostorage .................................................................................149 3.2.5. Sekcja deklaracji var ..................................................................................150 3.2.6. 3.2.7. Rozmieszczenie sekcji deklaracji danych w programie HLA .....................151 3.3. Przydziaï pamiÚci dla zmiennych w programach HLA ............................................152 3.4. Wyrównanie danych w programach HLA ...............................................................154 3.5. Wyraĝenia adresowe ...............................................................................................157 Koercja typów .........................................................................................................159 3.6. 3.7. Koercja typu rejestru ...............................................................................................162 PamiÚÊ obszaru stosu oraz instrukcje push i pop ....................................................164 3.8. Podstawowa postaÊ instrukcji push ..........................................................164 3.8.1. Podstawowa postaÊ instrukcji pop ............................................................166 3.8.2. 3.8.3. Zachowywanie wartoĂci rejestrów za pomocÈ instrukcji push i pop .......167 Stos jako kolejka LIFO .............................................................................................168 3.9.1. Pozostaïe wersje instrukcji obsïugi stosu ..................................................170 3.9.2. Usuwanie danych ze stosu bez ich zdejmowania ......................................172 3.10. Odwoïywanie siÚ do danych na stosie bez ich zdejmowania ..................................174 3.11. Dynamiczny przydziaï pamiÚci — obszar pamiÚci sterty ........................................176 Instrukcje inc oraz dec ............................................................................................181 3.12. 3.13. Pobieranie adresu obiektu .......................................................................................181 3.14. ½ródïa informacji dodatkowych ..............................................................................182 3.9. 4.1. 4.2. 4 STA’E, ZMIENNE I TYPY DANYCH ....................................................... 183 Kilka dodatkowych instrukcji: intmul, bound i into .................................................184 Deklaracje staïych i zmiennych w jÚzyku HLA ........................................................188 Typy staïych ..............................................................................................192 4.2.1. Literaïy staïych ïañcuchowych i znakowych ..............................................193 4.2.2. 4.2.3. Staïe ïañcuchowe i napisowe w sekcji const .............................................195 4.2.4. Wyraĝenia staïowartoĂciowe ....................................................................197 4.2.5. Wielokrotne sekcje const i ich kolejnoĂÊ w programach HLA ..................200 4.2.6. Sekcja val programu HLA ..........................................................................200 4.2.7. Modyfikowanie obiektów sekcji val 4.3. 4.4. 4.5. w wybranym miejscu kodu ěródïowego programu ..................................201 Sekcja type programu HLA .....................................................................................202 Typy wyliczeniowe w jÚzyku HLA ..........................................................................203 Typy wskaěnikowe ..................................................................................................204 4.5.1. Wskaěniki w jÚzyku asemblerowym .........................................................206 4.5.2. Deklarowanie wskaěników w programach HLA .......................................207 Staïe wskaěnikowe i wyraĝenia staïych wskaěnikowych ...........................208 4.5.3. Zmienne wskaěnikowe a dynamiczny przydziaï pamiÚci ..........................209 4.5.4. 4.5.5. Typowe bïÚdy stosowania wskaěników ....................................................209 S p i s t r e Ă c i 7 Zïoĝone typy danych .............................................................................................. 214 4.6. ’añcuchy znaków ................................................................................................... 214 4.7. ’añcuchy w jÚzyku HLA ......................................................................................... 217 4.8. Odwoïania do poszczególnych znaków ïañcucha ................................................... 224 4.9. 4.10. Moduï strings biblioteki standardowej HLA i procedury manipulacji ïañcuchami .... 226 4.11. Konwersje wewnÈtrzpamiÚciowe .......................................................................... 239 4.12. Zbiory znaków ....................................................................................................... 240 4.13. Implementacja zbiorów znaków w jÚzyku HLA ..................................................... 241 4.14. Literaïy, staïe i wyraĝenia zbiorów znaków w jÚzyku HLA .................................... 243 4.15. Obsïuga zbiorów znaków w bibliotece standardowej HLA ................................... 245 4.16. Wykorzystywanie zbiorów znaków w programach HLA ....................................... 249 4.17. Tablice .................................................................................................................... 250 4.18. Deklarowanie tablic w programach HLA ............................................................... 251 4.19. Literaïy tablicowe ................................................................................................... 252 4.20. Odwoïania do elementów tablicy jednowymiarowej ............................................. 254 PorzÈdkowanie tablicy wartoĂci ............................................................................. 255 4.21. 4.22. Tablice wielowymiarowe ........................................................................................ 257 4.22.1. Wierszowy ukïad elementów tablicy ........................................................ 258 4.22.2. Kolumnowy ukïad elementów tablicy ...................................................... 262 4.23. Przydziaï pamiÚci dla tablic wielowymiarowych ..................................................... 263 4.24. Odwoïania do elementów tablic wielowymiarowych w jÚzyku asemblerowym ..... 266 Rekordy (struktury) ................................................................................................ 267 4.25. Staïe rekordowe ..................................................................................................... 270 4.26. 4.27. Tablice rekordów ................................................................................................... 271 4.28. Wykorzystanie tablic i rekordów w roli pól rekordów .......................................... 272 4.29. Wyrównanie pól w ramach rekordu ...................................................................... 276 4.30. Wskaěniki na rekordy ............................................................................................. 278 4.31. Unie ........................................................................................................................ 279 4.32. Unie anonimowe .................................................................................................... 282 Typy wariantowe .................................................................................................... 283 4.33. Przestrzenie nazw .................................................................................................. 284 4.34. 4.35. Tablice dynamiczne w jÚzyku asemblerowym ....................................................... 288 4.36. ½ródïa informacji dodatkowych ............................................................................. 290 5 PROCEDURY I MODU’Y ........................................................................ 291 Procedury ............................................................................................................... 292 Zachowywanie stanu systemu ................................................................................ 294 Przedwczesny powrót z procedury ....................................................................... 299 Zmienne lokalne ..................................................................................................... 300 Symbole lokalne i globalne obiektów innych niĝ zmienne ...................................... 306 Parametry ............................................................................................................... 306 Przekazywanie przez wartoĂÊ .................................................................. 307 5.6.1. 5.6.2. Przekazywanie przez adres ...................................................................... 311 5.1. 5.2. 5.3. 5.4. 5.5. 5.6. 8 S p i s t r e Ă c i 5.7. Funkcje i wartoĂci funkcji ........................................................................................314 Zwracanie wartoĂci funkcji .......................................................................315 5.7.1. Zïoĝenie instrukcji jÚzyka HLA ..................................................................316 5.7.2. 5.7.3. Atrybut @returns procedur jÚzyka HLA ..................................................319 Rekurencja ...............................................................................................................321 5.8. 5.9. Deklaracje zapowiadajÈce .......................................................................................326 5.10. Deklaracje procedur w HLA 2.0 .............................................................................327 5.11. Procedury w ujÚciu niskopoziomowym — instrukcja call .......................................328 Rola stosu w procedurach .......................................................................................330 5.12. Rekordy aktywacji ...................................................................................................333 5.13. Standardowa sekwencja wejĂcia do procedury .......................................................336 5.14. 5.15. Standardowa sekwencja wyjĂcia z procedury .........................................................338 5.16. Niskopoziomowa implementacja zmiennych automatycznych ...............................340 5.17. Niskopoziomowa implementacja parametrów procedury .....................................342 5.17.1. Przekazywanie argumentów w rejestrach ................................................342 5.17.2. Przekazywanie argumentów w kodzie programu .....................................346 5.17.3. Przekazywanie argumentów przez stos ....................................................348 5.18. Wskaěniki na procedury ..........................................................................................373 5.19. Parametry typu procedurowego .............................................................................377 5.20. Nietypowane parametry wskaěnikowe ..................................................................378 5.21. ZarzÈdzanie duĝymi projektami programistycznymi ...............................................379 5.22. Dyrektywa #include ...............................................................................................380 5.23. Unikanie wielokrotnego wïÈczania do kodu tego samego pliku .............................383 5.24. Moduïy a atrybut external .......................................................................................384 5.24.1. Dziaïanie atrybutu external .......................................................................389 5.24.2. Pliki nagïówkowe w programach HLA ......................................................390 5.25. Jeszcze o problemie zaĂmiecania przestrzeni nazw ................................................392 5.26. ½ródïa informacji dodatkowych ..............................................................................395 6.1. 6 ARYTMETYKA ....................................................................................... 397 Zestaw instrukcji arytmetycznych procesora 80x86 ...............................................397 6.1.1. Instrukcje mul i imul ..................................................................................398 Instrukcje div i idiv .....................................................................................401 6.1.2. Instrukcja cmp ...........................................................................................404 6.1.3. Instrukcje setcc .........................................................................................409 6.1.4. 6.1.5. Instrukcja test ............................................................................................411 6.2. Wyraĝenia arytmetyczne .........................................................................................413 Proste przypisania .....................................................................................413 6.2.1. 6.2.2. Proste wyraĝenia .......................................................................................414 6.2.3. Wyraĝenia zïoĝone ....................................................................................417 6.2.4. Operatory przemienne .............................................................................423 6.3. Wyraĝenia logiczne ..................................................................................................424 S p i s t r e Ă c i 9 6.4. 6.5. 6.6. 6.7. 6.8. Idiomy maszynowe a idiomy arytmetyczne ............................................................ 427 6.4.1. Mnoĝenie bez stosowania instrukcji mul, imul i intmul ............................ 427 6.4.2. Dzielenie bez stosowania instrukcji div i idiv ............................................ 428 6.4.3. Zliczanie modulo n za poĂrednictwem instrukcji and ............................... 429 Arytmetyka zmiennoprzecinkowa .......................................................................... 430 Rejestry jednostki zmiennoprzecinkowej ................................................. 430 6.5.1. Typy danych jednostki zmiennoprzecinkowej .......................................... 438 6.5.2. Zestaw instrukcji jednostki zmiennoprzecinkowej ................................... 439 6.5.3. 6.5.4. Instrukcje przemieszczania danych ........................................................... 439 Instrukcje konwersji ................................................................................. 442 6.5.5. Instrukcje arytmetyczne ........................................................................... 445 6.5.6. Instrukcje porównañ ................................................................................. 451 6.5.7. 6.5.8. Instrukcje ïadowania staïych na stos koprocesora .................................... 454 6.5.9. Instrukcje funkcji przestÚpnych ................................................................ 455 6.5.10. Pozostaïe instrukcje jednostki zmiennoprzecinkowej .............................. 457 6.5.11. Instrukcje operacji caïkowitoliczbowych .................................................. 459 Tïumaczenie wyraĝeñ arytmetycznych na kod maszynowy jednostki zmiennoprzecinkowej ............................................. 459 Konwersja notacji wrostkowej do odwrotnej notacji polskiej ................. 461 6.6.1. 6.6.2. Konwersja odwrotnej notacji polskiej do kodu jÚzyka asemblerowego .... 464 Obsïuga arytmetyki zmiennoprzecinkowej w bibliotece standardowej jÚzyka HLA .................................................................. 465 ½ródïa informacji dodatkowych ............................................................................. 465 7 NISKOPOZIOMOWE STRUKTURY STERUJkCE WYKONANIEM PROGRAMU ............................................... 467 Struktury sterujÈce niskiego poziomu .................................................................... 468 7.1. Etykiety instrukcji ................................................................................................... 468 7.2. Bezwarunkowy skok do instrukcji (instrukcja jmp) ................................................ 470 7.3. Instrukcje skoku warunkowego .............................................................................. 473 7.4. Struktury sterujÈce „Ăredniego” poziomu — jt i jf ................................................. 477 7.5. 7.6. Implementacja popularnych struktur sterujÈcych w jÚzyku asemblerowym .......... 477 7.7. WstÚp do podejmowania decyzji ............................................................................ 478 Instrukcje if..then..else .............................................................................. 479 Tïumaczenie instrukcji if jÚzyka HLA na jÚzyk asemblerowy ................... 484 7.7.1. 7.7.2. 7.7.3. Obliczanie wartoĂci zïoĝonych wyraĝeñ logicznych — metoda peïnego obliczania wartoĂci wyraĝenia .................................. 489 7.7.4. Skrócone obliczanie wyraĝeñ logicznych .................................................. 490 7.7.5. Wady i zalety metod obliczania wartoĂci wyraĝeñ logicznych ................. 492 Efektywna implementacja instrukcji if w jÚzyku asemblerowym .............. 494 7.7.6. 7.7.7. Instrukcje wyboru ..................................................................................... 500 Skoki poĂrednie a automaty stanów ....................................................................... 511 Kod spaghetti .......................................................................................................... 514 7.8. 7.9. 10 S p i s t r e Ă c i 7.10. PÚtle ........................................................................................................................515 7.10.1. PÚtle while .................................................................................................515 7.10.2. PÚtle repeat..until ......................................................................................517 7.10.3. PÚtle nieskoñczone ...................................................................................518 7.10.4. PÚtle for ....................................................................................................519 7.10.5. Instrukcje break i continue ........................................................................521 7.10.6. PÚtle a rejestry ..........................................................................................525 7.11. Optymalizacja kodu .................................................................................................526 7.11.1. Obliczanie warunku zakoñczenia pÚtli na koñcu pÚtli ...............................526 7.11.2. Zliczanie licznika pÚtli wstecz ...................................................................529 7.11.3. WstÚpne obliczanie niezmienników pÚtli ..................................................530 7.11.4. RozciÈganie pÚtli ........................................................................................531 7.11.5. Zmienne indukcyjne ..................................................................................533 7.12. Mieszane struktury sterujÈce w jÚzyku HLA ...........................................................534 7.13. ½ródïa informacji dodatkowych ..............................................................................537 8 ZAAWANSOWANE OBLICZENIA W J}ZYKU ASEMBLEROWYM ............. 539 Operacje o zwielokrotnionej precyzji .....................................................................540 8.1.1. Obsïuga operacji zwielokrotnionej precyzji 8.1. w bibliotece standardowej jÚzyka HLA .....................................................540 8.1.2. Dodawanie liczb zwielokrotnionej precyzji ..............................................543 8.1.3. Odejmowanie liczb zwielokrotnionej precyzji ..........................................547 8.1.4. Porównanie wartoĂci o zwielokrotnionej precyzji ....................................548 8.1.5. Mnoĝenie operandów zwielokrotnionej precyzji ......................................553 8.1.6. Dzielenie wartoĂci zwielokrotnionej precyzji ...........................................556 8.1.7. Negacja operandów zwielokrotnionej precyzji .........................................566 Iloczyn logiczny operandów zwielokrotnionej precyzji ............................568 8.1.8. 8.1.9. Suma logiczna operandów zwielokrotnionej precyzji ...............................568 8.1.10. Suma wyïÈczajÈca operandów zwielokrotnionej precyzji .........................569 8.1.11. Inwersja operandów zwielokrotnionej precyzji ........................................569 8.1.12. PrzesuniÚcia bitowe operandów zwielokrotnionej precyzji .....................570 8.1.13. Obroty operandów zwielokrotnionej precyzji ..........................................574 8.1.14. Operandy zwielokrotnionej precyzji w operacjach wejĂcia-wyjĂcia .........575 Manipulowanie operandami róĝnych rozmiarów ....................................................597 Arytmetyka liczb dziesiÚtnych .................................................................................599 Literaïy liczb BCD .....................................................................................601 8.3.1. 8.3.2. Instrukcje maszynowe daa i das ................................................................601 Instrukcje maszynowe aaa, aas, aam i aad .................................................603 8.3.3. 8.3.4. Koprocesor a arytmetyka spakowanych liczb dziesiÚtnych ......................605 Obliczenia w tabelach .............................................................................................607 8.4.1. Wyszukiwanie w tabeli wartoĂci funkcji ....................................................607 8.4.2. Dopasowywanie dziedziny ........................................................................613 8.4.3. Generowanie tabel wartoĂci funkcji ..........................................................614 8.4.4. WydajnoĂÊ odwoïañ do tabel przeglÈdowych ...........................................618 ½ródïa informacji dodatkowych ..............................................................................618 8.2. 8.3. 8.4. 8.5. S p i s t r e Ă c i 11 9 MAKRODEFINICJE I J}ZYK CZASU KOMPILACJI ................................... 619 JÚzyk czasu kompilacji — wstÚp ............................................................................. 619 9.1. Instrukcje #print i #error ...................................................................................... 621 9.2. 9.3. Staïe i zmienne czasu kompilacji ............................................................................. 623 9.4. Wyraĝenia i operatory czasu kompilacji ................................................................. 624 Funkcje czasu kompilacji ......................................................................................... 626 9.5. 9.5.1. Funkcje czasu kompilacji — konwersja typów ......................................... 628 Funkcje czasu kompilacji — obliczenia numeryczne ................................ 630 9.5.2. Funkcje czasu kompilacji — klasyfikacja znaków ..................................... 630 9.5.3. 9.5.4. Funkcje czasu kompilacji — manipulacje ïañcuchami znaków ................. 631 9.5.5. Odwoïania do tablicy symboli .................................................................. 632 9.5.6. Pozostaïe funkcje czasu kompilacji ........................................................... 633 9.5.7. Konwersja typu staïych napisowych ......................................................... 634 Kompilacja warunkowa .......................................................................................... 635 Kompilacja wielokrotna (pÚtle czasu kompilacji) .................................................... 640 Makrodefinicje (procedury czasu kompilacji) ......................................................... 644 9.8.1. Makrodefinicje standardowe .................................................................... 644 Argumenty makrodefinicji ........................................................................ 647 9.8.2. 9.8.3. Symbole lokalne makrodefinicji ................................................................ 654 9.8.4. Makrodefinicje jako procedury czasu kompilacji ...................................... 657 9.8.5. Symulowane przeciÈĝanie funkcji ............................................................. 658 Tworzenie programów czasu kompilacji ................................................................ 664 9.9.1. Generowanie tabel wartoĂci funkcji ......................................................... 664 9.9.2. RozciÈganie pÚtli ....................................................................................... 669 9.10. Stosowanie makrodefinicji w osobnych plikach kodu ěródïowego ........................ 670 9.11. ½ródïa informacji dodatkowych ............................................................................. 671 9.6. 9.7. 9.8. 9.9. 10 MANIPULOWANIE BITAMI .................................................................... 673 10.1. Czym sÈ dane bitowe? ............................................................................................ 674 10.2. Instrukcje manipulujÈce bitami ............................................................................... 675 10.3. Znacznik przeniesienia w roli akumulatora bitów .................................................. 683 10.4. Wstawianie i wyodrÚbnianie ïañcuchów bitów ...................................................... 684 Scalanie zbiorów bitów i rozpraszanie ïañcuchów bitowych ................................. 688 10.5. 10.6. Spakowane tablice ïañcuchów bitowych ................................................................ 691 10.7. Wyszukiwanie bitów ............................................................................................... 693 10.8. Zliczanie bitów ....................................................................................................... 696 10.9. Odwracanie ïañcucha bitów ................................................................................... 699 10.10. Scalanie ïañcuchów bitowych ................................................................................. 701 10.11. WyodrÚbnianie ïañcuchów bitów ........................................................................... 702 10.12. Wyszukiwanie wzorca bitowego ............................................................................ 704 10.13. Moduï bits biblioteki standardowej HLA ................................................................ 705 10.14. ½ródïa informacji dodatkowych ............................................................................. 708 12 S p i s t r e Ă c i 11.1. 11 OPERACJE ’A”CUCHOWE ..................................................................... 709 Instrukcje ïañcuchowe procesorów 80x86 .............................................................710 11.1.1. Sposób dziaïania instrukcji ïañcuchowych .................................................710 11.1.2. Przedrostki instrukcji ïañcuchowych — repx ...........................................711 11.1.3. Znacznik kierunku .....................................................................................711 Instrukcja movs .........................................................................................714 11.1.4. 11.1.5. Instrukcja cmps .........................................................................................719 Instrukcja scas ...........................................................................................723 11.1.6. Instrukcja stos ...........................................................................................724 11.1.7. Instrukcja lods ...........................................................................................725 11.1.8. 11.1.9. Instrukcje lods i stos w zïoĝonych operacjach ïañcuchowych ...................726 11.2. WydajnoĂÊ instrukcji ïañcuchowych procesorów 80x86 ........................................726 11.3. ½ródïa informacji dodatkowych ..............................................................................727 12 KLASY I OBIEKTY .................................................................................. 729 12.1. WstÚp do programowania obiektowego .................................................................730 12.2. Klasy w jÚzyku HLA .................................................................................................733 12.3. Obiekty ...................................................................................................................736 12.4. Dziedziczenie ..........................................................................................................738 12.5. Przesïanianie ............................................................................................................739 12.6. Metody wirtualne a procedury statyczne ................................................................740 Implementacje metod i procedur klas .....................................................................742 12.7. 12.8. Implementacja obiektu ............................................................................................747 12.8.1. Tabela metod wirtualnych ........................................................................750 12.8.2. Reprezentacja w pamiÚci obiektu klasy pochodnej ...................................752 Konstruktory i inicjalizacja obiektów .......................................................................757 12.9.1. Konstruktor a dynamiczny przydziaï obiektu ............................................759 12.9.2. Konstruktory a dziedziczenie ....................................................................761 12.9.3. Parametry konstruktorów i przeciÈĝanie procedur klas ...........................765 12.10. Destruktory .............................................................................................................766 12.11. ’añcuchy _initialize_ oraz _finalize_ w jÚzyku HLA ................................................767 12.12. Metody abstrakcyjne ...............................................................................................774 12.13. Informacja o typie czasu wykonania (RTTI) ............................................................777 12.14. Wywoïania metod klasy bazowej ............................................................................779 12.15. ½ródïa informacji dodatkowych ..............................................................................780 12.9. A TABELA KODÓW ASCII .......................................................................... 781 SKOROWIDZ .......................................................................................... 785 S p i s t r e Ă c i 13 3 DostÚp do pamiÚci i jej organizacja Z LEKTURY DWÓCH POPRZEDNICH ROZDZIA’ÓW CZYTELNIK POZNA’ SPOSÓB DEKLAROWANIA I ODWO’YWANIA SI} DO ZMIENNYCH W PROGRAMACH J}ZYKA ASEMBLEROWEGO. W ROZDZIALE BIE¿kCYM POZNA PE’NY OBRAZ realizacji odwoïañ do pamiÚci w architekturze 80x86. Zaprezentowany zostanie równieĝ sposób organizacji danych pod kÈtem najefektywniejszego dostÚpu. Czytelnik dowie siÚ teĝ co nieco o stosie procesora 80x86 i sposobie manipulowania danymi na stosie. Rozdziaï zakoñczony zostanie omówieniem dynamiczne- go przydziaïu pamiÚci na stercie. W tym rozdziale bÚdziemy siÚ zajmowaÊ kilkoma kluczowymi zagadnieniami, miÚdzy innymi: Q trybami adresowania pamiÚci w procesorach 80x86, Q trybami adresowania indeksowanego i indeksowanego ze skalowaniem, Q organizacjÈ pamiÚci, Q przydziaïem pamiÚci do programu, Q koercjÈ typów danych, Q stosem procesora 80x86, Q dynamicznym przydziaïem pamiÚci. Dowiemy siÚ wiÚc, jak efektywnie korzystaÊ z zasobów pamiÚciowych komputera w progra- mach pisanych w jÚzyku HLA. 3.1. Tryby adresowania procesorów 80x86 Procesory z rodziny 80x86 realizujÈ dostÚp do pamiÚci w kilku róĝnych trybach. Jak dotychczas wszystkie prezentowane odwoïania do zmiennych realizowane byïy przez programy HLA w trybie, który okreĂla siÚ mianem trybu adresowania bezpoĂredniego. W tym rozdziale omó- wione zostanÈ jeszcze inne tryby adresowania dostÚpne programiĂcie jÚzyka asemblerowego procesora 80x86. DostÚpnoĂÊ wielu trybów adresowania pamiÚci pozwala na efektywny i elastyczny dostÚp do pamiÚci, co uïatwia tworzenie zmiennych, wskaěników, tablic, rekordów i innych zïoĝonych typów danych. Opanowanie wszystkich trybów adresowania pamiÚci realizowanych przez procesor 80x86 to pierwszy krok na drodze do opanowania jÚzyka asemblerowego pro- cesorów 80x86. Kiedy inĝynierowie z firmy Intel projektowali procesor 8086, wyposaĝyli go w elastyczny, choÊ równoczeĂnie ograniczony, zestaw trybów adresowania pamiÚci. Wraz z wprowadzeniem na rynek modelu 80386 zestaw ten zostaï rozszerzony o kilka kolejnych trybów. Niemniej jednak w Ărodowiskach 32-bitowych, czyli w systemach Windows, Mac OS X, Free BSD czy Linux, owe pierwotne tryby adresowania nie sÈ specjalnie uĝyteczne. W rzeczy samej jÚzyk HLA nie obsïu- guje nawet owych starszych, ĝeby nie powiedzieÊ przestarzaïych, 16-bitowych trybów adreso- wania. Na szczÚĂcie wszystkie operacje moĝliwe do wykonania w owych trybach da siÚ wyko- naÊ za poĂrednictwem nowych, 32-bitowych trybów adresowania. Z tego wzglÚdu omówienie 16-bitowych trybów adresowania moĝna pominÈÊ, jako ĝe we wspóïczesnych systemach ope- racyjnych sÈ one bezuĝyteczne. Jedynie ci spoĂród Czytelników, którzy zamierzajÈ tworzyÊ programy dla systemu MS-DOS i innych systemów szesnastobitowych, powinni zapoznaÊ siÚ z 16-bitowym adresowaniem pamiÚci (omówienie trybów szesnastobitowych znajduje siÚ w „16-bitowej” wersji niniejszej ksiÈĝki publikowanej w wersji elektronicznej w witrynie http://webster.cs.ucr.edu). 3.1.1. Adresowanie przez rejestr WiÚkszoĂÊ instrukcji zestawu instrukcji maszynowych procesora 80x86 wykorzystuje w roli operandów rejestry ogólnego przeznaczenia. DostÚp do rejestru uzyskuje siÚ, okreĂlajÈc w miejsce operandu instrukcji nazwÚ rejestru. Na przykïad dla instrukcji mov wyglÈda to nastÚpujÈco: mov( operand-ěródïowy, operand-docelowy ); Powyĝsza instrukcja kopiuje wartoĂÊ operandu ěródïowego do operandu docelowego. W szczególnoĂci operandami tymi mogÈ byÊ 8-bitowe, 16-bitowe i 32-bitowe rejestry procesora. 136 R o z d z i a ï 3. Jedynym ograniczeniem nakïadanym na takie operandy jest wymóg zgodnoĂci rozmiarów. Oto kilka przykïadów zastosowania instrukcji mov procesora 80x86: mov( bx, ax ); // Kopiowanie zawartoĞci rejestru BX do rejestru AX mov( al, dl ); // Kopiowanie zawartoĞci rejestru AL do rejestru DL mov( edx, esi ); // Kopiowanie zawartoĞci rejestru EDX do rejestru ESI mov( bp, sp ); // Kopiowanie zawartoĞci rejestru BP do rejestru SP mov( cl, dh ); // Kopiowanie zawartoĞci rejestru CL do rejestru DH mov( ax, ax ); // To równieĪ poprawna instrukcja! Rejestry sÈ wymarzonym miejscem do przechowywania zmiennych. Instrukcje odwoïujÈce siÚ do rejestrów sÈ wykonywane szybciej od tych, które odwoïujÈ siÚ do pamiÚci. Ich zapis jest teĝ krótszy. WiÚkszoĂÊ instrukcji obliczeniowych wymaga wprost, aby jeden z operandów byï umieszczony w rejestrze, stÈd adresowanie przez rejestr jest w kodzie asemblerowym procesora 80x86 bardzo czÚste. 3.1.2. 32-bitowe tryby adresowania procesora 80x86 Procesor 80x86 realizuje dostÚp do pamiÚci na setki rozmaitych sposobów. Na pierwszy rzut oka liczba trybów adresowania jest cokolwiek poraĝajÈca, ale na szczÚĂcie wiÚkszoĂÊ z nich to proste odmiany trybów podstawowych, stÈd ich opanowanie nie przysparza wiÚkszych trud- noĂci. A dobór odpowiedniego trybu adresowania to klucz do efektywnego programowania w asemblerze. Tryby adresowania implementowane w procesorach z rodziny 80x86 obejmujÈ adresowanie bezpoĂrednie, adresowanie bazowe, bazowe indeksowane, indeksowe oraz bazowe indeksowane z przemieszczeniem. Caïa niezliczona reszta trybów adresowania to odmiany owych trybów podstawowych. I tak przeszliĂmy od setek do zaledwie piÚciu trybów. To juĝ nieěle! 3.1.2.1. Adresowanie bezpoĂrednie NajczÚĂciej wykorzystywanym i najprostszym do opanowania trybem adresowania jest adresowa- nie bezpoĂrednie (ang. displacement-only). W tym trybie adres docelowy okreĂlany jest 32-bi- towÈ staïÈ. JeĂli na przykïad zmienna J jest zmiennÈ typu int8 umieszczonÈ pod adresem $8088, to instrukcja mov(J, al) oznacza zaïadowanie do rejestru AL kopii bajta spod adresu $8088. Analogicznie, jeĂli przyjÈÊ, ĝe zmienna K typu int8 znajduje siÚ pod adresem $1234, to instrukcja mov( dl, K ) powoduje zachowanie wartoĂci rejestru DL pod adresem $1234 (patrz rysunek 3.1). Tryb adresowania bezpoĂredniego Ăwietnie nadaje siÚ do realizacji odwoïañ do prostych zmiennych skalarnych. Dla tego trybu przyjÚto nazwÚ „adresowanie z przemieszczeniem”, poniewaĝ bezpoĂrednio po kodzie instrukcji mov w pamiÚci zapisana jest trzydziestodwubitowa staïa przemieszczenia. Przemieszczenie w procesorach 80x86 definiowane jest jako przesu- niÚcie (ang. offset) od poczÈtkowego adresu pamiÚci (czyli adresu zerowego). W przykïadach prezentowanych w tej ksiÈĝce znaczna liczba instrukcji to odwoïania do pojedynczych bajtów w pamiÚci. Nie naleĝy jednak zapominaÊ, ĝe w pamiÚci moĝna przechowywaÊ równieĝ obiekty rozmiarów sïowa i podwójnego sïowa, i równieĝ ich adres okreĂla siÚ, podajÈc adres pierwszego bajta obiektu (patrz rysunek 3.2). D o s t Ú p d o p a m i Ú c i i j e j o r g a n i z a c j a 137 Rysunek 3.1. Tryb adresowania bezpoĂredniego Rysunek 3.2. Odwoïanie do sïowa i podwójnego sïowa w trybie adresowania bezpoĂredniego 3.1.2.2. Adresowanie poĂrednie przez rejestr Procesory z rodziny 80x86 pozwalajÈ na odwoïania do pamiÚci realizowane za poĂrednictwem rejestru, w tak zwanym trybie adresowania poĂredniego przez rejestr. Termin „poĂrednie” oznacza tu, ĝe operand nie jest wïaĂciwym adresem; dopiero wartoĂÊ operandu okreĂla adres odwoïania. W adresowaniu poĂrednim przez rejestr wartoĂÊ rejestru to docelowy adres pamiÚci. Na przykïad instrukcja mov( eax, [ebx] ) informuje procesor, aby ten zachowaï zawartoĂÊ rejestru EAX w miejscu, którego adres znajduje siÚ w rejestrze EBX. Tryb adresowania poĂred- niego przez rejestr jest w jÚzyku HLA sygnalizowany nawiasami prostokÈtnymi. Procesory 80x86 obsïugujÈ osiem wersji adresowania poĂredniego przez rejestr; wersje te moĝna zademonstrowaÊ na nastÚpujÈcych przykïadach: mov( [eax], al ); mov( [ebx], al ); mov( [ecx], al ); mov( [edx], al ); mov( [edi], al ); mov( [esi], al ); mov( [ebp], al ); mov( [esp], al ); 138 R o z d z i a ï 3. Wersje te róĝniÈ siÚ tylko rejestrem, w którym przechowywany jest wïaĂciwy adres ope- randu. WartoĂÊ rejestru interpretowana jest jako przesuniÚcie operandu w pamiÚci. W adresowaniu poĂrednim przez rejestr konieczne jest stosowanie rejestrów 32-bitowych. Nie moĝna okreĂliÊ przesuniÚcia w pamiÚci w rejestrze 16-bitowym ani tym bardziej w reje- strze 8-bitowym1. Teoretycznie 32-bitowy rejestr moĝna zaïadowaÊ dowolnÈ wartoĂciÈ i w ten sposób okreĂliÊ dowolny adres wïaĂciwego operandu: mov( $1234_5678, ebx ); mov( [ebx], al ); // Próba odwoáania siĊ do adresu $1234_5678 Niestety (albo na szczÚĂcie) próba taka spowoduje najpewniej wygenerowanie przez sys- tem operacyjny bïÚdu ochrony pamiÚci, poniewaĝ nie zawsze program moĝe odwoïywaÊ siÚ do dowolnych obszarów pamiÚci. SÈ jednak inne metody zaïadowania rejestru adresem pewnego obiektu; o tym póěniej. Adresowanie poĂrednie przez rejestr ma bardzo wiele zastosowañ. Moĝna w ten sposób odwoïywaÊ siÚ do danych, dysponujÈc jedynie wskaěnikami na nie, moĝna teĝ, zwiÚkszajÈc wartoĂÊ rejestru, przechodziÊ pomiÚdzy elementami tablicy. W ogólnoĂci tryb ten nadaje siÚ do modyfikowania adresu docelowego odwoïania w czasie dziaïania programu. Adresowanie poĂrednie przez rejestr to przykïad trybu adresowania z dostÚpem „w ciemno”. Kiedy adres odwoïania zadany jest wartoĂciÈ rejestru, nie ma mowy o nazwie zmiennej — obiekt docelowy identyfikowany jest wyïÈcznie wartoĂciÈ adresu. Obiekt taki moĝna wiÚc okreĂliÊ mianem „obiektu anonimowego”. JÚzyk HLA udostÚpnia prosty operator pozwalajÈcy na zaïadowanie 32-bitowego rejestru adresem zmiennej, o ile jest to zmienna statyczna. Operator pobrania adresu ma postaÊ iden- tycznÈ jak w jÚzykach C i C++ — jest to znak . Poniĝszy przykïad demonstruje sposób zaïa- dowania rejestru EBX adresem zmiennej J, a nastÚpnie zapisania w rejestrze EAX bieĝÈcej wartoĂci tej zmiennej przy uĝyciu adresowania poĂredniego przez rejestr: mov( J, ebx ); // Zaáadowanie rejestru EBX adresem zmiennej J. mov( eax, [ebx] ); // zapisanie w zmiennej J wartoĞci rejestru EAX. Co prawda ïatwiej byïoby po prostu pojedynczÈ instrukcjÈ mov umieĂciÊ wartoĂÊ zmiennej J w rejestrze EAX, zamiast angaĝowaÊ dwie instrukcje po to tylko, aby zrobiÊ to poĂrednio przez rejestr. ’atwo moĝna sobie jednak wyobraziÊ sekwencjÚ kodu, w ramach której do rejestru EBX ïadowany jest adres jednej z wielu zmiennych, w zaleĝnoĂci od pewnych warunków, a potem — juĝ niezaleĝnie od nich — do rejestru EAX trafia wartoĂÊ odpowiedniej zmiennej. Ostrzeĝenie Operator pobrania adresu ( ) nie jest operatorem o zastosowaniu tak ogólnym, jak jego odpo- wiednik znany z jÚzyków C i C++. Operator ten moĝna w jÚzyku HLA zastosowaÊ wyïÈcznie 1 Tak naprawdÚ procesory z rodziny 80x86 wciÈĝ obsïugujÈ tryby adresowania poĂredniego przez 16-bitowy rejestr. Tryb ten w Ărodowisku 32-bitowym nie ma jednak zastosowania i jako taki nie jest obsïugiwany w jÚzyku HLA. D o s t Ú p d o p a m i Ú c i i j e j o r g a n i z a c j a 139 do zmiennych statycznych2. Nie moĝna uĝywaÊ go do wyraĝeñ adresowych i zmiennych innych niĝ statyczne. Bardziej uniwersalny sposób pobrania adresu zmiennej w pamiÚci zostanie zaprezen- towany w podrozdziale 3.13, przy okazji omawiania instrukcji ïadowania adresu efektywnego. 3.1.2.3. Adresowanie indeksowe Tryb adresowania indeksowego wykorzystuje nastÚpujÈcÈ skïadniÚ instrukcji: mov( zmienna[ eax ], al ); mov( zmienna[ ebx ], al ); mov( zmienna[ ecx ], al ); mov( zmienna[ edx ], al ); mov( zmienna[ edi ], al ); mov( zmienna[ esi ], al ); mov( zmienna[ ebp ], al ); mov( zmienna[ esp ], al ); gdzie zmienna jest nazwÈ zmiennej programu. W trybie adresowania indeksowego obliczany jest efektywny adres obiektu docelowego3; polega to na dodaniu do adresu zmiennej wartoĂci zapisanej w 32-bitowym rejestrze umiesz- czonym w nawiasach prostokÈtnych. Dopiero suma tych wartoĂci okreĂla wïaĂciwy adres pamiÚci, do którego ma nastÈpiÊ odwoïanie. JeĂli wiÚc zmienna przechowywana jest w pamiÚci pod adre- sem $1100, a rejestr EBX zawiera wartoĂÊ 8, to wykonanie instrukcji mov( zmienna[ ebx ], al ) powoduje umieszczenie w rejestrze AL wartoĂci zapisanej w pamiÚci pod adresem $1108. CaïoĂÊ zostaïa zilustrowana rysunkiem 3.3. Rysunek 3.3. Adresowanie indeksowe Tryb adresowania indeksowego jest szczególnie porÚczny do odwoïywania siÚ do elementów tablic. Takie jego zastosowanie zostanie bliĝej omówione w rozdziale 4. 2 Zmienne statyczne obejmujÈ obiekty deklarowane ze sïowem kluczowym static, readonly oraz storage. 3 Adres efektywny to adres ostateczny, do którego procesor odwoïa siÚ w wyniku wykonania instrukcji. Jest to wiÚc efekt koñcowy procesu ustalania adresu odwoïania. 140 R o z d z i a ï 3. 3.1.2.4. Warianty trybu adresowania indeksowego JÚzyk HLA przewiduje dwie waĝne odmiany podstawowego trybu adresowania indeksowego. Obie odmiany generujÈ co prawda te same instrukcje maszynowe, ale ich skïadnia sugeruje odmienne przeznaczenie. Pierwszy wariant korzysta z nastÚpujÈcej skïadni: mov( [ebx + staïa], al ); mov( [ebx - staïa], al ); W powyĝszym przykïadzie wykorzystywany jest jedynie rejestr EBX, ale w trybie adresowania indeksowego moĝna wykorzystywaÊ wszystkie 32-bitowe rejestry ogólnego przeznaczenia. Adres efektywny jest w tym trybie wyliczany przez dodanie do zawartoĂci rejestru EBX okreĂlonej staïej, ewentualnie odjÚcie tej staïej od wartoĂci rejestru EBX (patrz rysunki 3.4 oraz 3.5). Rysunek 3.4. Adresowanie indeksowe: wartoĂÊ rejestru plus staïa Rysunek 3.5. Adresowanie indeksowe: wartoĂÊ rejestru minus staïa Ten konkretny wariant adresowania jest przydatny, jeĂli 32-bitowy rejestr zawiera adres bazowy obiektu wielobajtowego i zachodzi koniecznoĂÊ odwoïania siÚ do adresu skïadowej obiektu, oddalonego od adresu bazowego o pewnÈ liczbÚ bajtów. Tryb ten wykorzystuje siÚ wiÚc w odwoïaniach do skïadowych (pól) struktur (rekordów), gdy struktura zadana jest wskaěni- kiem. Tryb ten oddaje równieĝ nieocenione usïugi w odwoïaniach do zmiennych automatycz- nych (lokalnych wzglÚdem procedury — patrz rozdziaï 5.). Drugi wariant adresowania indeksowego to w istocie poïÈczenie dwóch znanych nam juĝ trybów. Jego skïadnia prezentuje siÚ nastÚpujÈco: D o s t Ú p d o p a m i Ú c i i j e j o r g a n i z a c j a 141 mov( zmienna[ ebx + staïa ], al ); mov( zmienna[ ebx - staïa ], al ); Tutaj znów zastosowany zostaï rejestr EBX, co nie oznacza, ĝe w trybie tym nie moĝna wyko- rzystywaÊ pozostaïych 32-bitowych rejestrów ogólnego przeznaczenia. Niniejsza wersja adre- sowania indeksowego jest szczególnie uĝyteczna w odwoïaniach do skïadowych struktur prze- chowywanych w tablicy (patrz rozdziaï 4.). W omawianym trybie adresowania adres efektywny operandu oblicza siÚ przez dodanie bÈdě odjÚcie staïej od adresu zmiennej, a nastÚpnie dodanie wyniku do zawartoĂci rejestru. Warto pamiÚtaÊ, ĝe to kompilator, a nie procesor, oblicza sumÚ (bÈdě róĝnicÚ) staïej i adresu zmiennej. Powyĝsze instrukcje sÈ bowiem na poziomie maszynowym implementowane za poĂrednic- twem pojedynczej instrukcji, dodajÈcej pewnÈ wartoĂÊ do rejestru EBX. Z racji podstawiania przez kompilator w miejsce zmiennej jej staïego adresu, instrukcja: mov( zmienna[ ebx + staïa ], al ); redukowana jest do nastÚpujÈcej instrukcji: mov( staïa1[ ebx + staïa2 ], al ); Ze wzglÚdu na sposób dziaïania trybu adresowania powyĝsza instrukcja jest zaĂ równowaĝna nastÚpujÈcej: mov( [ ebx + (staïa1 + staïa2) ], al ); Obie staïe sÈ sumowane na etapie kompilacji, co ostatecznie daje nastÚpujÈcÈ instrukcjÚ maszynowÈ: mov( [ ebx + suma_staïych ], al ); OczywiĂcie sprawy majÈ siÚ identycznie równieĝ przy odejmowaniu. Róĝnica pomiÚdzy try- bami adresowania z dodawaniem i odejmowaniem staïych moĝe zostaÊ bowiem ïatwo zniwe- lowana — przy odejmowaniu staïÈ wystarczy obliczyÊ uzupeïnienie do dwóch odejmowanej staïej, i tak otrzymanÈ wartoĂÊ po prostu dodaÊ do rejestru — dodawanie od odejmowania róĝni siÚ wiÚc tylko pojedynczÈ operacjÈ negacji, równieĝ zresztÈ realizowanÈ na etapie kompilacji. 3.1.2.5. Adresowanie indeksowe skalowane Tryb adresowania indeksowego skalowanego przypomina zaprezentowane tryby adresowania indeksowego. Róĝni siÚ od nich zaledwie dwoma elementami: po pierwsze, w adresowaniu indek- sowym skalowanym moĝna uwikïaÊ, oprócz wartoĂci przemieszczenia, zawartoĂÊ dwóch rejestrów; 142 R o z d z i a ï 3. po drugie, tryb adresowania indeksowego skalowanego pozwala na wymnoĝenie rejestru indek- sowego przez wspóïczynnik (skalÚ) o wartoĂci 1, 2, 4 bÈdě 8. SkïadniÚ tego trybu okreĂla siÚ nastÚpujÈco: zmienna[ rejestr-indeksowy32 * skala ] zmienna[ rejestr-indeksowy32 * skala + przesuniÚcie ] zmienna[ rejestr-indeksowy32 * skala - przesuniÚcie ] [ rejestr-bazowy32 + rejestr-indeksowy32 * skala ] [ rejestr-bazowy32 + rejestr-indeksowy32 * skala + przesuniÚcie ] [ rejestr-bazowy32 + rejestr-indeksowy32 * skala - przesuniÚcie ] zmienna[ rejestr-bazowy32 + rejestr-indeksowy32 * skala ] zmienna[ rejestr-bazowy32 + rejestr-indeksowy32 * skala + przesuniÚcie ] zmienna[ rejestr-bazowy32 + rejestr-indeksowy32 * skala - przesuniÚcie ] W powyĝszych przykïadach rejestr-bazowy32 reprezentuje dowolny z 32-bitowych rejestrów ogólnego przeznaczenia, podobnie jak rejestr-indeksowy32 (z puli dostÚpnych dla tego operandu rejestrów naleĝy jednak wykluczyÊ rejestr ESP); skala jest staïÈ o wartoĂci 1, 2, 4 bÈdě 8. Skalowane adresowanie indeksowe róĝni siÚ od prostego adresowania indeksowego przede wszystkim skïadowÈ rejestr-indeksowy32 * skala. W trybie tym adres efektywny obliczany jest przez dodanie wartoĂci rejestru indeksowego pomnoĝonej przez wspóïczynnik skalowania. Dopiero ta wartoĂÊ wykorzystywana jest w roli indeksu. Sposób obliczania adresu efektywnego w tym trybie ilustrowany jest rysunkiem 3.6 (w roli rejestru bazowego wystÚpuje na nim rejestr EBX; rejestrem indeksowym jest ESI). Rysunek 3.6. Adresowanie indeksowe skalowane JeĂli dla sytuacji rozrysowanej na rysunku 3.6 przyjÈÊ, ĝe rejestr EBX zawiera wartoĂÊ $100, rejestr ESI zawiera wartoĂÊ $20, a zmienna zostaïa umieszczona w pamiÚci pod adresem $2000, wtedy instrukcja: mov( zmienna[ ebx + esi*4 + 4], al); D o s t Ú p d o p a m i Ú c i i j e j o r g a n i z a c j a 143 spowoduje skopiowanie do rejestru AL pojedynczego bajta spod adresu $2184 ($2000+ $100+$20*4+4). Adresowanie indeksowe skalowane przydatne jest w odwoïaniach do elementów tablicy, w której wszystkie elementy majÈ rozmiary dwóch, czterech bÈdě oĂmiu bajtów. Wykorzystuje siÚ go równieĝ w odwoïaniach do elementów tablicy, kiedy dany jest wskaěnik do poczÈtkowego elementu tablicy. 3.1.2.6. Adresowanie w piguïce Zapewne Czytelnik bÚdzie powÈtpiewaï w te sïowa, ale wïaĂnie poznaï kilkaset trybów adreso- wania! Okazaïo siÚ to nie takie trudne, prawda? JeĂli wciÈĝ siÚ to Czytelnikowi nie mieĂci w gïo- wie, powinien wziÈÊ pod uwagÚ, ĝe, na przykïad, tryb adresowania poĂredniego przez rejestr nie jest pojedynczym trybem — obejmuje osiem trybów dla oĂmiu róĝnych rejestrów. Wszystkie kilkaset trybów powstaje wïaĂnie w wyniku kombinacji rejestrów, rozmiarów staïych i innych czynników. Tymczasem wystarczy zapoznaÊ siÚ z okoïo dwudziestoma kilkoma postaciami odwoïañ do pamiÚci, aby posïugiwaÊ siÚ caïÈ dostÚpnÈ gamÈ trybów adresowania. W praktyce zresztÈ w nawet najbardziej rozbudowanych wykorzystuje siÚ i tak mniej niĝ poïowÚ dostÚpnych trybów (wielu nie wykorzystuje siÚ niemal wcale). Okazuje siÚ wiÚc, ĝe opanowanie adresowa- nia pamiÚci nie jest takie trudne. 3.2. Organizacja pamiÚci fazy wykonania W systemach operacyjnych takich jak Mac OS X, FreeBSD, Linux czy Windows róĝne rodzaje danych programów umieszczane sÈ w róĝnych sekcjach czy teĝ obszarach pamiÚci. Co prawda przy uruchamianiu programu konsolidujÈcego moĝna ingerowaÊ w konfiguracjÚ pamiÚci pro- gramu, okreĂlajÈc szereg opcji wywoïania, ale domyĂlnie programy jÚzyka HLA w systemie Windows majÈ w pamiÚci reprezentacjÚ takÈ jak na rysunku 3.7 (to samo dotyczy zresztÈ syste- mów Linux, Mac OS X i FreeBSD; tam niektóre sekcje sÈ jedynie inaczej rozmieszczone). Rysunek 3.7. Typowe rozmieszczenie elementów programu HLA w pamiÚci 144 R o z d z i a ï 3. Najniĝsze adresy przestrzeni adresowej programu rezerwowane sÈ przez system operacyjny. W ogólnoĂci aplikacje nie mogÈ odwoïywaÊ siÚ do tego obszaru ani wykonywaÊ w nim instruk- cji. Obszar ten sïuĝy systemowi operacyjnemu miÚdzy innymi do przechwytywania odwoïañ realizowanych za poĂrednictwem wskaěników pustych (NULL). JeĂli instrukcja programu próbuje odwoïaÊ siÚ do adresu zerowego (taki adres odpowiada wskaěnikowi pustemu), system operacyjny generuje bïÈd ochrony „general protection fault” sygnalizujÈcy próbÚ odwoïania do pamiÚci niedostÚpnej dla programu. ProgramiĂci czÚsto inicjalizujÈ zmienne wskaěnikowe wartoĂciÈ NULL (zerem); wartoĂÊ ta sygnalizuje potem, ĝe wskaěnik nie wskazuje jeszcze na nic, a odwoïanie za poĂrednictwem takiego wskaěnika oznacza zazwyczaj bïÈd w programie pole- gajÈcy na nieprawidïowej inicjalizacji wskaěnika. Pozostaïych szeĂÊ obszarów mapy pamiÚci programu to obszary przypisane do poszczególnych rodzajów danych. Mamy tu obszar stosu, obszar sterty, obszar kodu, obszar danych niemodyfi- kowalnych (readonly), obszar zmiennych statycznych oraz obszar pamiÚci niezainicjalizowanej (storage). Kaĝdy z tych obszarów sïuĝy do przechowywania okreĂlonych typów danych deklaro- wanych w programach jÚzyka HLA. ZostanÈ one szczegóïowo omówione w kolejnych punktach. 3.2.1. Obszar kodu Obszar kodu zawiera instrukcje maszynowe tworzÈce wïaĂciwy program HLA. Kompilator jÚzyka HLA tïumaczy instrukcje maszynowe kodu ěródïowego do postaci sekwencji wartoĂci jedno- bÈdě kilkubajtowy
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Asembler. Sztuka programowania. Wydanie II
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ą: