Asembler. Sztuka Programowania. Wydanie II

Id do
Spis treci
Przykadowy rozdzia
Katalog ksiek
Asembler. Sztuka
programowania. Wydanie II
Autor: Randall Hyde
Tumaczenie: Przemysaw Szeremiota
ISBN: 978-83-246-2854-4
Tytu oryginau: The Art of Assembly Language, 2nd edition
Format: B5, stron: 816
Katalog online
Zamw drukowany
katalog
Twj koszyk
Dodaj do koszyka
Cennik i informacje
Zamw informacje
o nowociach
Zamw cennik
Czytelnia
Fragmenty ksiek
online
Kontakt
Helion SA
ul. Kociuszki 1c
44-100 Gliwice
tel. 32 230 98 63
e-mail: helion@helion.pl
Helion 19912010
Poznaj asembler od podstaw i zbuduj fundament swojej wiedzy o programowaniu

Jak pisa, kompilowa i uruchamia programy w jzyku HLA?
Jak obsugiwa zbiory znakw w bibliotece standardowej HLA?
Jak oblicza wartoci wyrae logicznych?
Poznanie asemblera jest jak pooenie fundamentu pod budowl caej twojej wiedzy informatycznej,
poniewa to wanie ono uatwia zrozumienie mechanizmw rzdzcych innymi jzykami
programowania. Jzyk asemblera, nalecy do jzykw programowania niszego poziomu, jest
powszechnie stosowany do pisania sterownikw, emulatorw i gier wideo. Jednak omawiany
w tej ksice jzyk HLA posiada te wiele cech jzykw wyszego poziomu, takich jak C, C++ czy
Java, dziki czemu przy jego uywaniu nie musisz rezygnowa z licznych udogodnie, typowych
dla takich jzykw.
Ksika Asembler. Sztuka programowania. Wydanie II stanowi obszerne i wyczerpujce
omwienie jzyka asemblera. Dziki wielu jasnym przykadom, pozbawionym niepotrzebnej
specjalistycznej terminologii, zawarty tu materia staje si atwo przyswajalny dla kadego, kto
chciaby pozna programowanie niszego poziomu. Korzystajc z tego podrcznika, dowiesz si
m.in., jak deklarowa i stosowa stae, zmienne skalarne, wskaniki, tablice, struktury, unie
i przestrzenie nazw. Nauczysz si realizowa w jzyku asemblera struktury sterujce przebiegiem
wykonania programu. Ponadto drugie wydanie zostao uaktualnione zgodnie ze zmianami, ktre
zaszy w jzyku HLA. Uwzgldnia take stosowanie HLA w kontekcie systemw Windows, Linux,
Mac OS X i FreeBSD.
Wstp do asemblera
Anatomia programu HLA
Reprezentacja danych
Dostp do pamici i jej organizacja
Stae, zmienne i typy danych
Procedury i moduy
Niskopoziomowe struktury sterujce wykonaniem programu
Makrodefinicje i jzyk czasu kompilacji
Manipulowanie bitami
Klasy i obiekty
Podrcznik na najwyszym poziomie o jzykach programowania niszego poziomu
Spis treci
PODZIKOWANIA ................................................................................... 15
1
WSTP
1.1.
1.2.
1.3.
1.4.
1.5.
1.6.
1.7.
1.8.
1.9.
DO JZYKA ASEMBLEROWEGO .................................................... 17

Anatomia programu HLA ..........................................................................................18
Uruchamianie pierwszego programu HLA ................................................................20
Podstawowe deklaracje danych programu HLA .......................................................22
Wartoci logiczne ......................................................................................................24
Wartoci znakowe .....................................................................................................25
Rodzina procesorw 80x86 firmy Intel .....................................................................25
Podsystem obsugi pamici .......................................................................................28
Podstawowe instrukcje maszynowe .........................................................................31
Podstawowe struktury sterujce wykonaniem programu HLA ................................34
1.9.1. Wyraenia logiczne w instrukcjach HLA .....................................................35
1.9.2. Instrukcje if..then..elseif..else..endif jzyka HLA .........................................37
1.9.3. Iloczyn, suma i negacja w wyraeniach logicznych ......................................39
1.9.4. Instrukcja while ...........................................................................................42
1.9.5. Instrukcja for ...............................................................................................43
1.9.6. Instrukcja repeat .........................................................................................44
1.9.7. Instrukcje break oraz breakif ......................................................................45
1.9.8. Instrukcja forever ........................................................................................45
1.9.9. Instrukcje try, exception oraz endtry ..........................................................46
1.10. Biblioteka standardowa jzyka HLA wprowadzenie ............................................50
1.10.1. Stae predefiniowane w module stdio .........................................................52
1.10.2. Standardowe wejcie i wyjcie 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.11.
1.12.
1.13.
Jeszcze o ochronie wykonania kodu w bloku try..endtry ......................................... 62

1.11.1. Zagniedone 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
Jzyk asemblerowy a jzyk HLA ............................................................................... 70
rda informacji dodatkowych ............................................................................... 71
2
REPREZENTACJA DANYCH ..................................................................... 73
2.1.
Systemy liczbowe ..................................................................................................... 74
2.1.1. System dziesitny przypomnienie .......................................................... 74
2.1.2. System dwjkowy ...................................................................................... 74
2.1.3. Formaty liczb dwjkowych ........................................................................ 75
2.2.
System szesnastkowy ............................................................................................... 76
2.3.
Organizacja danych ................................................................................................... 79
2.3.1. Bity ............................................................................................................. 79
2.3.2. Pbajty ....................................................................................................... 79
2.3.3. Bajty ............................................................................................................ 80
2.3.4. Sowa .......................................................................................................... 82
2.3.5. Podwjne sowa ......................................................................................... 83
2.3.6. Sowa poczwrne i dugie ........................................................................... 84
2.4.
Operacje arytmetyczne na liczbach dwjkowych 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 dwjkowych i cigach bitw .................................... 91
2.8.
Liczby ze znakiem i bez znaku .................................................................................. 93
2.9.
Rozszerzanie znakiem, rozszerzanie zerem, skracanie, przycinanie ........................ 98
2.10. Przesunicia i obroty .............................................................................................. 102
2.11. Pola bitowe i dane spakowane ............................................................................... 107
2.12. Wprowadzenie do arytmetyki zmiennoprzecinkowej ............................................ 112
2.12.1. Formaty zmiennoprzecinkowe przyjte przez IEEE ................................ 116
2.12.2. Obsuga liczb zmiennoprzecinkowych w jzyku HLA .............................. 120
2.13. Reprezentacja liczb BCD ........................................................................................ 124
2.14. Znaki ....................................................................................................................... 125
2.14.1. Zestaw znakw ASCII .............................................................................. 125
2.14.2. Obsuga znakw ASCII w jzyku HLA ..................................................... 129
2.15. Zestaw znakw Unicode ........................................................................................ 134
2.16. rda informacji dodatkowych ............................................................................. 134
3
DOSTP DO PAMICI I JEJ ORGANIZACJA ............................................ 135
3.1.
Tryby adresowania procesorw 80x86 .................................................................. 136
3.1.1. Adresowanie przez rejestr ....................................................................... 136
3.1.2. 32-bitowe tryby adresowania procesora 80x86 ....................................... 137
Spis treci
3.2.
3.3.
3.4.
3.5.
3.6.
3.7.
3.8.
3.9.
3.10.
3.11.
3.12.
3.13.
3.14.
Organizacja pamici 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
3.2.5. Atrybut @nostorage .................................................................................149
3.2.6. Sekcja deklaracji var ..................................................................................150
3.2.7. Rozmieszczenie sekcji deklaracji danych w programie HLA .....................151
Przydzia pamici dla zmiennych w programach HLA ............................................152
Wyrwnanie danych w programach HLA ...............................................................154
Wyraenia adresowe ...............................................................................................157
Koercja typw .........................................................................................................159
Koercja typu rejestru ...............................................................................................162
Pami obszaru stosu oraz instrukcje push i pop ....................................................164
3.8.1. Podstawowa posta instrukcji push ..........................................................164
3.8.2. Podstawowa posta instrukcji pop ............................................................166
3.8.3. Zachowywanie wartoci rejestrw za pomoc instrukcji push i pop .......167
Stos jako kolejka LIFO .............................................................................................168
3.9.1. Pozostae wersje instrukcji obsugi stosu ..................................................170
3.9.2. Usuwanie danych ze stosu bez ich zdejmowania ......................................172
Odwoywanie si do danych na stosie bez ich zdejmowania ..................................174
Dynamiczny przydzia pamici obszar pamici sterty ........................................176
Instrukcje inc oraz dec ............................................................................................181
Pobieranie adresu obiektu .......................................................................................181
rda informacji dodatkowych ..............................................................................182
4
STAE, ZMIENNE I TYPY DANYCH ....................................................... 183
4.1.
Kilka dodatkowych instrukcji: intmul, bound i into .................................................184
4.2.
Deklaracje staych i zmiennych w jzyku HLA ........................................................188
4.2.1. Typy staych ..............................................................................................192
4.2.2. Literay staych a cuchowych i znakowych ..............................................193
4.2.3. Stae a cuchowe i napisowe w sekcji const .............................................195
4.2.4. Wyraenia staowartociowe ....................................................................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 obiektw sekcji val
w wybranym miejscu kodu
rdowego programu ..................................201
4.3.
Sekcja type programu HLA .....................................................................................202
4.4.
Typy wyliczeniowe w jzyku HLA ..........................................................................203
4.5.
Typy wska
nikowe ..................................................................................................204
4.5.1. Wska
niki w jzyku asemblerowym .........................................................206
4.5.2. Deklarowanie wska
nikw w programach HLA .......................................207
4.5.3. Stae wska
nikowe i wyraenia staych wska
nikowych ...........................208
4.5.4. Zmienne wska
nikowe a dynamiczny przydzia pamici ..........................209
4.5.5. Typowe bdy stosowania wska
nikw ....................................................209
Spis treci
4.6.
4.7.
4.8.
4.9.
4.10.
4.11.
4.12.
4.13.
4.14.
4.15.
4.16.
4.17.
4.18.
4.19.
4.20.
4.21.
4.22.
4.23.
4.24.
4.25.
4.26.
4.27.
4.28.
4.29.
4.30.
4.31.
4.32.
4.33.
4.34.
4.35.
4.36.
Zoone typy danych .............................................................................................. 214

a cuchy znakw ................................................................................................... 214
a cuchy w jzyku HLA ......................................................................................... 217
Odwoania do poszczeglnych znakw a cucha ................................................... 224
Modu strings biblioteki standardowej HLA i procedury manipulacji a cuchami .... 226
Konwersje wewntrzpamiciowe .......................................................................... 239
Zbiory znakw ....................................................................................................... 240
Implementacja zbiorw znakw w jzyku HLA ..................................................... 241
Literay, stae i wyraenia zbiorw znakw w jzyku HLA .................................... 243
Obsuga zbiorw znakw w bibliotece standardowej HLA ................................... 245
Wykorzystywanie zbiorw znakw w programach HLA ....................................... 249
Tablice .................................................................................................................... 250
Deklarowanie tablic w programach HLA ............................................................... 251
Literay tablicowe ................................................................................................... 252
Odwoania do elementw tablicy jednowymiarowej ............................................. 254
Porzdkowanie tablicy wartoci ............................................................................. 255
Tablice wielowymiarowe ........................................................................................ 257
4.22.1. Wierszowy ukad elementw tablicy ........................................................ 258
4.22.2. Kolumnowy ukad elementw tablicy ...................................................... 262
Przydzia pamici dla tablic wielowymiarowych ..................................................... 263
Odwoania do elementw tablic wielowymiarowych w jzyku asemblerowym ..... 266
Rekordy (struktury) ................................................................................................ 267
Stae rekordowe ..................................................................................................... 270
Tablice rekordw ................................................................................................... 271
Wykorzystanie tablic i rekordw w roli pl rekordw .......................................... 272
Wyrwnanie pl w ramach rekordu ...................................................................... 276
Wska
niki na rekordy ............................................................................................. 278
Unie ........................................................................................................................ 279
Unie anonimowe .................................................................................................... 282
Typy wariantowe .................................................................................................... 283
Przestrzenie nazw .................................................................................................. 284
Tablice dynamiczne w jzyku asemblerowym ....................................................... 288
rda informacji dodatkowych ............................................................................. 290
5
PROCEDURY I MODUY ........................................................................ 291
5.1.
Procedury ............................................................................................................... 292
5.2.
Zachowywanie stanu systemu ................................................................................ 294
5.3.
Przedwczesny powrt z procedury ....................................................................... 299
5.4.
Zmienne lokalne ..................................................................................................... 300
5.5.
Symbole lokalne i globalne obiektw innych ni zmienne ...................................... 306
5.6.
Parametry ............................................................................................................... 306
5.6.1. Przekazywanie przez warto .................................................................. 307
5.6.2. Przekazywanie przez adres ...................................................................... 311
Spis treci
5.7.
5.8.
5.9.
5.10.
5.11.
5.12.
5.13.
5.14.
5.15.
5.16.
5.17.
5.18.
5.19.
5.20.
5.21.
5.22.
5.23.
5.24.
5.25.
5.26.
Funkcje i wartoci funkcji ........................................................................................314

5.7.1. Zwracanie wartoci funkcji .......................................................................315
5.7.2. Zoenie instrukcji jzyka HLA ..................................................................316
5.7.3. Atrybut @returns procedur jzyka HLA ..................................................319
Rekurencja ...............................................................................................................321
Deklaracje zapowiadajce .......................................................................................326
Deklaracje procedur w HLA 2.0 .............................................................................327
Procedury w ujciu niskopoziomowym instrukcja call .......................................328
Rola stosu w procedurach .......................................................................................330
Rekordy aktywacji ...................................................................................................333
Standardowa sekwencja wejcia do procedury .......................................................336
Standardowa sekwencja wyjcia z procedury .........................................................338
Niskopoziomowa implementacja zmiennych automatycznych ...............................340
Niskopoziomowa implementacja parametrw procedury .....................................342
5.17.1. Przekazywanie argumentw w rejestrach ................................................342
5.17.2. Przekazywanie argumentw w kodzie programu .....................................346
5.17.3. Przekazywanie argumentw przez stos ....................................................348
Wska
niki na procedury ..........................................................................................373
Parametry typu procedurowego .............................................................................377
Nietypowane parametry wska
nikowe ..................................................................378
Zarzdzanie duymi projektami programistycznymi ...............................................379
Dyrektywa #include ...............................................................................................380
Unikanie wielokrotnego wczania do kodu tego samego pliku .............................383
Moduy a atrybut external .......................................................................................384
5.24.1. Dziaanie atrybutu external .......................................................................389
5.24.2. Pliki nagwkowe w programach HLA ......................................................390
Jeszcze o problemie zamiecania przestrzeni nazw ................................................392
6
ARYTMETYKA ....................................................................................... 397
6.1.
Zestaw instrukcji arytmetycznych procesora 80x86 ...............................................397
6.1.1. Instrukcje mul i imul ..................................................................................398
6.1.2. Instrukcje div i idiv .....................................................................................401
6.1.3. Instrukcja cmp ...........................................................................................404
6.1.4. Instrukcje setcc .........................................................................................409
6.1.5. Instrukcja test ............................................................................................411
6.2.
Wyraenia arytmetyczne .........................................................................................413
6.2.1. Proste przypisania .....................................................................................413
6.2.2. Proste wyraenia .......................................................................................414
6.2.3. Wyraenia zoone ....................................................................................417
6.2.4. Operatory przemienne .............................................................................423
6.3.
Wyraenia logiczne ..................................................................................................424
Spis treci
6.4.
6.5.
6.6.
6.7.
6.8.
Idiomy maszynowe a idiomy arytmetyczne ............................................................ 427

6.4.1. Mnoenie 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 porednictwem instrukcji and ............................... 429
Arytmetyka zmiennoprzecinkowa .......................................................................... 430
6.5.1. Rejestry jednostki zmiennoprzecinkowej ................................................. 430
6.5.2. Typy danych jednostki zmiennoprzecinkowej .......................................... 438
6.5.3. Zestaw instrukcji jednostki zmiennoprzecinkowej ................................... 439
6.5.4. Instrukcje przemieszczania danych ........................................................... 439
6.5.5. Instrukcje konwersji ................................................................................. 442
6.5.6. Instrukcje arytmetyczne ........................................................................... 445
6.5.7. Instrukcje porwna ................................................................................. 451
6.5.8. Instrukcje adowania staych na stos koprocesora .................................... 454
6.5.9. Instrukcje funkcji przestpnych ................................................................ 455
6.5.10. Pozostae instrukcje jednostki zmiennoprzecinkowej .............................. 457
6.5.11. Instrukcje operacji cakowitoliczbowych .................................................. 459
Tumaczenie wyrae arytmetycznych
na kod maszynowy jednostki zmiennoprzecinkowej ............................................. 459
6.6.1. Konwersja notacji wrostkowej do odwrotnej notacji polskiej ................. 461
6.6.2. Konwersja odwrotnej notacji polskiej do kodu jzyka asemblerowego .... 464
Obsuga arytmetyki zmiennoprzecinkowej
w bibliotece standardowej jzyka HLA .................................................................. 465
rda informacji dodatkowych ............................................................................. 465
7
NISKOPOZIOMOWE STRUKTURY
STERUJCE WYKONANIEM PROGRAMU ............................................... 467
7.1.
Struktury sterujce niskiego poziomu .................................................................... 468
7.2.
Etykiety instrukcji ................................................................................................... 468
7.3.
Bezwarunkowy skok do instrukcji (instrukcja jmp) ................................................ 470
7.4.
Instrukcje skoku warunkowego .............................................................................. 473
7.5.
Struktury sterujce redniego poziomu jt i jf ................................................. 477
7.6.
Implementacja popularnych struktur sterujcych w jzyku asemblerowym .......... 477
7.7.
Wstp do podejmowania decyzji ............................................................................ 478
7.7.1. Instrukcje if..then..else .............................................................................. 479
7.7.2. Tumaczenie instrukcji if jzyka HLA na jzyk asemblerowy ................... 484
7.7.3. Obliczanie wartoci zoonych wyrae logicznych
metoda penego obliczania wartoci wyraenia .................................. 489
7.7.4. Skrcone obliczanie wyrae logicznych .................................................. 490
7.7.5. Wady i zalety metod obliczania wartoci wyrae logicznych ................. 492
7.7.6. Efektywna implementacja instrukcji if w jzyku asemblerowym .............. 494
7.7.7. Instrukcje wyboru ..................................................................................... 500
7.8.
Skoki porednie a automaty stanw ....................................................................... 511
7.9.
Kod spaghetti .......................................................................................................... 514
10
Spis treci
7.10.
7.11.
7.12.
7.13.
Ptle ........................................................................................................................515
7.10.1. Ptle while .................................................................................................515
7.10.2. Ptle repeat..until ......................................................................................517
7.10.3. Ptle niesko czone ...................................................................................518
7.10.4. Ptle for ....................................................................................................519
7.10.5. Instrukcje break i continue ........................................................................521
7.10.6. Ptle a rejestry ..........................................................................................525
Optymalizacja kodu .................................................................................................526
7.11.1. Obliczanie warunku zako czenia ptli na ko cu ptli ...............................526
7.11.2. Zliczanie licznika ptli wstecz ...................................................................529
7.11.3. Wstpne obliczanie niezmiennikw ptli ..................................................530
7.11.4. Rozciganie ptli ........................................................................................531
7.11.5. Zmienne indukcyjne ..................................................................................533
Mieszane struktury sterujce w jzyku HLA ...........................................................534
8
ZAAWANSOWANE OBLICZENIA W JZYKU ASEMBLEROWYM ............. 539
8.1.
Operacje o zwielokrotnionej precyzji .....................................................................540
8.1.1. Obsuga operacji zwielokrotnionej precyzji
w bibliotece standardowej jzyka HLA .....................................................540
8.1.2. Dodawanie liczb zwielokrotnionej precyzji ..............................................543
8.1.3. Odejmowanie liczb zwielokrotnionej precyzji ..........................................547
8.1.4. Porwnanie wartoci o zwielokrotnionej precyzji ....................................548
8.1.5. Mnoenie operandw zwielokrotnionej precyzji ......................................553
8.1.6. Dzielenie wartoci zwielokrotnionej precyzji ...........................................556
8.1.7. Negacja operandw zwielokrotnionej precyzji .........................................566
8.1.8. Iloczyn logiczny operandw zwielokrotnionej precyzji ............................568
8.1.9. Suma logiczna operandw zwielokrotnionej precyzji ...............................568
8.1.10. Suma wyczajca operandw zwielokrotnionej precyzji .........................569
8.1.11. Inwersja operandw zwielokrotnionej precyzji ........................................569
8.1.12. Przesunicia bitowe operandw zwielokrotnionej precyzji .....................570
8.1.13. Obroty operandw zwielokrotnionej precyzji ..........................................574
8.1.14. Operandy zwielokrotnionej precyzji w operacjach wejcia-wyjcia .........575
8.2.
Manipulowanie operandami rnych rozmiarw ....................................................597
8.3.
Arytmetyka liczb dziesitnych .................................................................................599
8.3.1. Literay liczb BCD .....................................................................................601
8.3.2. Instrukcje maszynowe daa i das ................................................................601
8.3.3. Instrukcje maszynowe aaa, aas, aam i aad .................................................603
8.3.4. Koprocesor a arytmetyka spakowanych liczb dziesitnych ......................605
8.4.
Obliczenia w tabelach .............................................................................................607
8.4.1. Wyszukiwanie w tabeli wartoci funkcji ....................................................607
8.4.2. Dopasowywanie dziedziny ........................................................................613
8.4.3. Generowanie tabel wartoci funkcji ..........................................................614
8.4.4. Wydajno odwoa do tabel przegldowych ...........................................618
8.5.
Spis treci
11
9
MAKRODEFINICJE I JZYK CZASU KOMPILACJI ................................... 619
9.1.
Jzyk czasu kompilacji wstp ............................................................................. 619
9.2.
Instrukcje #print i #error ...................................................................................... 621
9.3.
Stae i zmienne czasu kompilacji ............................................................................. 623
9.4.
Wyraenia i operatory czasu kompilacji ................................................................. 624
9.5.
Funkcje czasu kompilacji ......................................................................................... 626
9.5.1. Funkcje czasu kompilacji konwersja typw ......................................... 628
9.5.2. Funkcje czasu kompilacji obliczenia numeryczne ................................ 630
9.5.3. Funkcje czasu kompilacji klasyfikacja znakw ..................................... 630
9.5.4. Funkcje czasu kompilacji manipulacje a cuchami znakw ................. 631
9.5.5. Odwoania do tablicy symboli .................................................................. 632
9.5.6. Pozostae funkcje czasu kompilacji ........................................................... 633
9.5.7. Konwersja typu staych napisowych ......................................................... 634
9.6.
Kompilacja warunkowa .......................................................................................... 635
9.7.
Kompilacja wielokrotna (ptle czasu kompilacji) .................................................... 640
9.8.
Makrodefinicje (procedury czasu kompilacji) ......................................................... 644
9.8.1. Makrodefinicje standardowe .................................................................... 644
9.8.2. Argumenty makrodefinicji ........................................................................ 647
9.8.3. Symbole lokalne makrodefinicji ................................................................ 654
9.8.4. Makrodefinicje jako procedury czasu kompilacji ...................................... 657
9.8.5. Symulowane przecianie funkcji ............................................................. 658
9.9.
Tworzenie programw czasu kompilacji ................................................................ 664
9.9.1. Generowanie tabel wartoci funkcji ......................................................... 664
9.9.2. Rozciganie ptli ....................................................................................... 669
9.10. Stosowanie makrodefinicji w osobnych plikach kodu
rdowego ........................ 670
10
MANIPULOWANIE BITAMI .................................................................... 673
10.1. Czym s dane bitowe? ............................................................................................ 674
10.2. Instrukcje manipulujce bitami ............................................................................... 675
10.3. Znacznik przeniesienia w roli akumulatora bitw .................................................. 683
10.4. Wstawianie i wyodrbnianie a cuchw bitw ...................................................... 684
10.5. Scalanie zbiorw bitw i rozpraszanie a cuchw bitowych ................................. 688
10.6. Spakowane tablice a cuchw bitowych ................................................................ 691
10.7. Wyszukiwanie bitw ............................................................................................... 693
10.8. Zliczanie bitw ....................................................................................................... 696
10.9. Odwracanie a cucha bitw ................................................................................... 699
10.10. Scalanie a cuchw bitowych ................................................................................. 701
10.11. Wyodrbnianie a cuchw bitw ........................................................................... 702
10.12. Wyszukiwanie wzorca bitowego ............................................................................ 704
10.13. Modu bits biblioteki standardowej HLA ................................................................ 705
12
Spis treci
11
OPERACJE ACUCHOWE ..................................................................... 709
11.1. Instrukcje a cuchowe procesorw 80x86 .............................................................710
11.1.1. Sposb dziaania instrukcji a cuchowych .................................................710
11.1.2. Przedrostki instrukcji a cuchowych repx ...........................................711
11.1.3. Znacznik kierunku .....................................................................................711
11.1.4. Instrukcja movs .........................................................................................714
11.1.5. Instrukcja cmps .........................................................................................719
11.1.6. Instrukcja scas ...........................................................................................723
11.1.7. Instrukcja stos ...........................................................................................724
11.1.8. Instrukcja lods ...........................................................................................725
11.1.9. Instrukcje lods i stos w zoonych operacjach a cuchowych ...................726
11.2. Wydajno instrukcji a cuchowych procesorw 80x86 ........................................726
11.3. rda informacji dodatkowych ..............................................................................727
12
KLASY
12.1.
12.2.
12.3.
12.4.
12.5.
12.6.
12.7.
12.8.
12.9.
12.10.
12.11.
12.12.
12.13.
12.14.
12.15.
I OBIEKTY .................................................................................. 729

Wstp do programowania obiektowego .................................................................730
Klasy w jzyku HLA .................................................................................................733
Obiekty ...................................................................................................................736
Dziedziczenie ..........................................................................................................738
Przesanianie ............................................................................................................739
Metody wirtualne a procedury statyczne ................................................................740
Implementacje metod i procedur klas .....................................................................742
Implementacja obiektu ............................................................................................747
12.8.1. Tabela metod wirtualnych ........................................................................750
12.8.2. Reprezentacja w pamici obiektu klasy pochodnej ...................................752
Konstruktory i inicjalizacja obiektw .......................................................................757
12.9.1. Konstruktor a dynamiczny przydzia obiektu ............................................759
12.9.2. Konstruktory a dziedziczenie ....................................................................761
12.9.3. Parametry konstruktorw i przecianie procedur klas ...........................765
Destruktory .............................................................................................................766
a cuchy _initialize_ oraz _finalize_ w jzyku HLA ................................................767
Metody abstrakcyjne ...............................................................................................774
Informacja o typie czasu wykonania (RTTI) ............................................................777
Wywoania metod klasy bazowej ............................................................................779
A
TABELA KODW ASCII .......................................................................... 781
SKOROWIDZ .......................................................................................... 785
Spis treci
13
3
Dostp do pamici
i jej organizacja
LEKTURY DWCH POPRZEDNICH ROZDZIAW
CZYTELNIK POZNA SPOSB
DEKLAROWANIA I ODWOYWANIA SI DO ZMIENNYCH W PROGRAMACH

J ZYKA ASEMBLEROWEGO.
W ROZDZIALE BIECYM POZNA PENY OBRAZ

realizacji odwoa do pamici w architekturze 80x86. Zaprezentowany
zostanie rwnie sposb organizacji danych pod ktem najefektywniejszego
dostpu. Czytelnik dowie si te co nieco o stosie procesora 80x86 i sposobie
manipulowania danymi na stosie. Rozdzia zako czony zostanie omwieniem dynamicznego przydziau pamici na stercie.
W tym rozdziale bdziemy si zajmowa kilkoma kluczowymi zagadnieniami, midzy innymi:
Q trybami adresowania pamici w procesorach 80x86,
Q trybami adresowania indeksowanego i indeksowanego ze skalowaniem,
Q organizacj pamici,
Q przydziaem pamici do programu,
Q koercj typw danych,
Q stosem procesora 80x86,

Q dynamicznym przydziaem pamici.
Dowiemy si wic, jak efektywnie korzysta z zasobw pamiciowych komputera w programach pisanych w jzyku HLA.
3.1. Tryby adresowania procesorw 80x86

Procesory z rodziny 80x86 realizuj dostp do pamici w kilku rnych trybach. Jak dotychczas
wszystkie prezentowane odwoania do zmiennych realizowane byy przez programy HLA
w trybie, ktry okrela si mianem trybu adresowania bezporedniego. W tym rozdziale omwione zostan jeszcze inne tryby adresowania dostpne programicie jzyka asemblerowego
procesora 80x86. Dostpno wielu trybw adresowania pamici pozwala na efektywny i elastyczny
dostp do pamici, co uatwia tworzenie zmiennych, wskanikw, tablic, rekordw i innych
zoonych typw danych. Opanowanie wszystkich trybw adresowania pamici realizowanych
przez procesor 80x86 to pierwszy krok na drodze do opanowania jzyka asemblerowego procesorw 80x86.
Kiedy inynierowie z firmy Intel projektowali procesor 8086, wyposayli go w elastyczny,
cho rwnoczenie ograniczony, zestaw trybw adresowania pamici. Wraz z wprowadzeniem
na rynek modelu 80386 zestaw ten zosta rozszerzony o kilka kolejnych trybw. Niemniej jednak
w rodowiskach 32-bitowych, czyli w systemach Windows, Mac OS X, Free BSD czy Linux, owe
pierwotne tryby adresowania nie s specjalnie uyteczne. W rzeczy samej jzyk HLA nie obsuguje nawet owych starszych, eby nie powiedzie przestarzaych, 16-bitowych trybw adresowania. Na szczcie wszystkie operacje moliwe do wykonania w owych trybach da si wykona za porednictwem nowych, 32-bitowych trybw adresowania. Z tego wzgldu omwienie
16-bitowych trybw adresowania mona pomin, jako e we wspczesnych systemach operacyjnych s one bezuyteczne. Jedynie ci spord Czytelnikw, ktrzy zamierzaj tworzy
programy dla systemu MS-DOS i innych systemw szesnastobitowych, powinni zapozna si
z 16-bitowym adresowaniem pamici (omwienie trybw szesnastobitowych znajduje si
w 16-bitowej wersji niniejszej ksiki publikowanej w wersji elektronicznej w witrynie
http://webster.cs.ucr.edu).
3.1.1. Adresowanie przez rejestr

Wikszo instrukcji zestawu instrukcji maszynowych procesora 80x86 wykorzystuje w roli
operandw rejestry oglnego przeznaczenia. Dostp do rejestru uzyskuje si, okrelajc w miejsce
operandu instrukcji nazw rejestru. Na przykad dla instrukcji mov wyglda to nastpujco:
mov( operand-rdowy, operand-docelowy );
Powysza instrukcja kopiuje warto operandu rdowego do operandu docelowego.

W szczeglnoci operandami tymi mog by 8-bitowe, 16-bitowe i 32-bitowe rejestry procesora.
1 36
Rozdzia 3.
Jedynym ograniczeniem nakadanym na takie operandy jest wymg zgodnoci rozmiarw. Oto
kilka przykadw zastosowania instrukcji mov procesora 80x86:
mov(
mov(
mov(
mov(
mov(
mov(
bx, ax );
al, dl );
edx, esi );
bp, sp );
cl, dh );
ax, ax );
// Kopiowanie zawartoci rejestru BX do rejestru AX

// Kopiowanie zawartoci rejestru AL do rejestru DL
// Kopiowanie zawartoci rejestru EDX do rejestru ESI
// Kopiowanie zawartoci rejestru BP do rejestru SP
// Kopiowanie zawartoci rejestru CL do rejestru DH
// To rwnie poprawna instrukcja!
Rejestry s wymarzonym miejscem do przechowywania zmiennych. Instrukcje odwoujce

si do rejestrw s wykonywane szybciej od tych, ktre odwouj si do pamici. Ich zapis jest
te krtszy. Wikszo instrukcji obliczeniowych wymaga wprost, aby jeden z operandw by
umieszczony w rejestrze, std adresowanie przez rejestr jest w kodzie asemblerowym procesora
80x86 bardzo czste.
3.1.2. 32-bitowe tryby adresowania procesora 80x86

Procesor 80x86 realizuje dostp do pamici na setki rozmaitych sposobw. Na pierwszy rzut
oka liczba trybw adresowania jest cokolwiek poraajca, ale na szczcie wikszo z nich to
proste odmiany trybw podstawowych, std ich opanowanie nie przysparza wikszych trudnoci. A dobr odpowiedniego trybu adresowania to klucz do efektywnego programowania
w asemblerze.
Tryby adresowania implementowane w procesorach z rodziny 80x86 obejmuj adresowanie
bezporednie, adresowanie bazowe, bazowe indeksowane, indeksowe oraz bazowe indeksowane
z przemieszczeniem. Caa niezliczona reszta trybw adresowania to odmiany owych trybw
podstawowych. I tak przeszlimy od setek do zaledwie piciu trybw. To ju niele!
3.1.2.1. Adresowanie bezporednie

Najczciej wykorzystywanym i najprostszym do opanowania trybem adresowania jest adresowanie bezporednie (ang. displacement-only). W tym trybie adres docelowy okrelany jest 32-bitow sta. Jeli na przykad zmienna J jest zmienn typu int8 umieszczon pod adresem $8088,
to instrukcja mov(J, al) oznacza zaadowanie do rejestru AL kopii bajta spod adresu $8088.
Analogicznie, jeli przyj, e zmienna K typu int8 znajduje si pod adresem $1234, to instrukcja
mov( dl, K ) powoduje zachowanie wartoci rejestru DL pod adresem $1234 (patrz rysunek 3.1).
Tryb adresowania bezporedniego wietnie nadaje si do realizacji odwoa do prostych
zmiennych skalarnych. Dla tego trybu przyjto nazw adresowanie z przemieszczeniem,
poniewa bezporednio po kodzie instrukcji mov w pamici zapisana jest trzydziestodwubitowa
staa przemieszczenia. Przemieszczenie w procesorach 80x86 definiowane jest jako przesunicie (ang. offset) od pocztkowego adresu pamici (czyli adresu zerowego). W przykadach
prezentowanych w tej ksice znaczna liczba instrukcji to odwoania do pojedynczych bajtw
w pamici. Nie naley jednak zapomina, e w pamici mona przechowywa rwnie obiekty
rozmiarw sowa i podwjnego sowa, i rwnie ich adres okrela si, podajc adres pierwszego
bajta obiektu (patrz rysunek 3.2).
1 37
Rysunek 3.1. Tryb adresowania bezporedniego
Rysunek 3.2. Odwoanie do sowa i podwjnego sowa w trybie adresowania bezporedniego
3.1.2.2. Adresowanie porednie przez rejestr

Procesory z rodziny 80x86 pozwalaj na odwoania do pamici realizowane za porednictwem
rejestru, w tak zwanym trybie adresowania poredniego przez rejestr. Termin porednie
oznacza tu, e operand nie jest waciwym adresem; dopiero warto operandu okrela adres
odwoania. W adresowaniu porednim przez rejestr warto rejestru to docelowy adres pamici.
Na przykad instrukcja mov( eax, [ebx] ) informuje procesor, aby ten zachowa zawarto
rejestru EAX w miejscu, ktrego adres znajduje si w rejestrze EBX. Tryb adresowania poredniego przez rejestr jest w jzyku HLA sygnalizowany nawiasami prostoktnymi.
Procesory 80x86 obsuguj osiem wersji adresowania poredniego przez rejestr; wersje te
mona zademonstrowa na nastpujcych przykadach:
mov(
mov(
mov(
mov(
mov(
mov(
mov(
mov(
1 38
[eax],
[ebx],
[ecx],
[edx],
[edi],
[esi],
[ebp],
[esp],
al
al
al
al
al
al
al
al
);
);
);
);
);
);
);
);
Rozdzia 3.
Wersje te rni si tylko rejestrem, w ktrym przechowywany jest waciwy adres operandu. Warto rejestru interpretowana jest jako przesunicie operandu w pamici.
W adresowaniu porednim przez rejestr konieczne jest stosowanie rejestrw 32-bitowych.
Nie mona okreli przesunicia w pamici w rejestrze 16-bitowym ani tym bardziej w rejestrze 8-bitowym1. Teoretycznie 32-bitowy rejestr mona zaadowa dowoln wartoci i w ten
sposb okreli dowolny adres waciwego operandu:
mov( $1234_5678, ebx );
mov( [ebx], al );
// Prba odwoania si do adresu $1234_5678
Niestety (albo na szczcie) prba taka spowoduje najpewniej wygenerowanie przez system operacyjny bdu ochrony pamici, poniewa nie zawsze program moe odwoywa si
do dowolnych obszarw pamici. S jednak inne metody zaadowania rejestru adresem pewnego
obiektu; o tym pniej.
Adresowanie porednie przez rejestr ma bardzo wiele zastosowa . Mona w ten sposb
odwoywa si do danych, dysponujc jedynie wskanikami na nie, mona te, zwikszajc
warto rejestru, przechodzi pomidzy elementami tablicy. W oglnoci tryb ten nadaje si
do modyfikowania adresu docelowego odwoania w czasie dziaania programu.
Adresowanie porednie przez rejestr to przykad trybu adresowania z dostpem w ciemno.
Kiedy adres odwoania zadany jest wartoci rejestru, nie ma mowy o nazwie zmiennej obiekt
docelowy identyfikowany jest wycznie wartoci adresu. Obiekt taki mona wic okreli
mianem obiektu anonimowego.
Jzyk HLA udostpnia prosty operator pozwalajcy na zaadowanie 32-bitowego rejestru
adresem zmiennej, o ile jest to zmienna statyczna. Operator pobrania adresu ma posta identyczn jak w jzykach C i C++ jest to znak &. Poniszy przykad demonstruje sposb zaadowania rejestru EBX adresem zmiennej J, a nastpnie zapisania w rejestrze EAX biecej
wartoci tej zmiennej przy uyciu adresowania poredniego przez rejestr:
mov( &J, ebx );
mov( eax, [ebx] );
// Zaadowanie rejestru EBX adresem zmiennej J.

// zapisanie w zmiennej J wartoci rejestru EAX.
Co prawda atwiej byoby po prostu pojedyncz instrukcj mov umieci warto zmiennej J
w rejestrze EAX, zamiast angaowa dwie instrukcje po to tylko, aby zrobi to porednio przez
rejestr. atwo mona sobie jednak wyobrazi sekwencj kodu, w ramach ktrej do rejestru
EBX adowany jest adres jednej z wielu zmiennych, w zalenoci od pewnych warunkw,
a potem ju niezalenie od nich do rejestru EAX trafia warto odpowiedniej zmiennej.
Ostrzeenie
Operator pobrania adresu (&) nie jest operatorem o zastosowaniu tak oglnym, jak jego odpowiednik znany z jzykw C i C++. Operator ten mona w jzyku HLA zastosowa wycznie
1
Tak naprawd procesory z rodziny 80x86 wci obsuguj tryby adresowania poredniego przez 16-bitowy
rejestr. Tryb ten w rodowisku 32-bitowym nie ma jednak zastosowania i jako taki nie jest obsugiwany
w jzyku HLA.
1 39
do zmiennych statycznych2. Nie mona uywa go do wyrae adresowych i zmiennych innych ni
statyczne. Bardziej uniwersalny sposb pobrania adresu zmiennej w pamici zostanie zaprezentowany w podrozdziale 3.13, przy okazji omawiania instrukcji adowania adresu efektywnego.
3.1.2.3. Adresowanie indeksowe

Tryb adresowania indeksowego wykorzystuje nastpujc skadni instrukcji:
mov(
mov(
mov(
mov(
mov(
mov(
mov(
mov(
zmienna[
zmienna[
zmienna[
zmienna[
zmienna[
zmienna[
zmienna[
zmienna[
eax
ebx
ecx
edx
edi
esi
ebp
esp
],
],
],
],
],
],
],
],
al
al
al
al
al
al
al
al
);
);
);
);
);
);
);
);
gdzie zmienna jest nazw zmiennej programu.

W trybie adresowania indeksowego obliczany jest efektywny adres obiektu docelowego3;
polega to na dodaniu do adresu zmiennej wartoci zapisanej w 32-bitowym rejestrze umieszczonym w nawiasach prostoktnych. Dopiero suma tych wartoci okrela waciwy adres pamici,
do ktrego ma nastpi odwoanie. Jeli wic zmienna przechowywana jest w pamici pod adresem $1100, a rejestr EBX zawiera warto 8, to wykonanie instrukcji mov( zmienna[ ebx ], al )
powoduje umieszczenie w rejestrze AL wartoci zapisanej w pamici pod adresem $1108.
Cao zostaa zilustrowana rysunkiem 3.3.
Rysunek 3.3. Adresowanie indeksowe

Tryb adresowania indeksowego jest szczeglnie porczny do odwoywania si do elementw
tablic. Takie jego zastosowanie zostanie bliej omwione w rozdziale 4.
2
3
Zmienne statyczne obejmuj obiekty deklarowane ze sowem kluczowym static, readonly oraz storage.
Adres efektywny to adres ostateczny, do ktrego procesor odwoa si w wyniku wykonania instrukcji.
Jest to wic efekt ko cowy procesu ustalania adresu odwoania.
1 40
Rozdzia 3.
3.1.2.4. Warianty trybu adresowania indeksowego

Jzyk HLA przewiduje dwie wane odmiany podstawowego trybu adresowania indeksowego.
Obie odmiany generuj co prawda te same instrukcje maszynowe, ale ich skadnia sugeruje
odmienne przeznaczenie.
Pierwszy wariant korzysta z nastpujcej skadni:
mov( [ebx + staa], al );
mov( [ebx - staa], al );
W powyszym przykadzie wykorzystywany jest jedynie rejestr EBX, ale w trybie adresowania
indeksowego mona wykorzystywa wszystkie 32-bitowe rejestry oglnego przeznaczenia. Adres
efektywny jest w tym trybie wyliczany przez dodanie do zawartoci rejestru EBX okrelonej staej,
ewentualnie odjcie tej staej od wartoci rejestru EBX (patrz rysunki 3.4 oraz 3.5).
Rysunek 3.4. Adresowanie indeksowe: warto rejestru plus staa
Rysunek 3.5. Adresowanie indeksowe: warto rejestru minus staa

Ten konkretny wariant adresowania jest przydatny, jeli 32-bitowy rejestr zawiera adres
bazowy obiektu wielobajtowego i zachodzi konieczno odwoania si do adresu skadowej
obiektu, oddalonego od adresu bazowego o pewn liczb bajtw. Tryb ten wykorzystuje si
wic w odwoaniach do skadowych (pl) struktur (rekordw), gdy struktura zadana jest wskanikiem. Tryb ten oddaje rwnie nieocenione usugi w odwoaniach do zmiennych automatycznych (lokalnych wzgldem procedury patrz rozdzia 5.).
Drugi wariant adresowania indeksowego to w istocie poczenie dwch znanych nam ju
trybw. Jego skadnia prezentuje si nastpujco:
1 41
mov( zmienna[ ebx + staa ], al );

mov( zmienna[ ebx - staa ], al );
Tutaj znw zastosowany zosta rejestr EBX, co nie oznacza, e w trybie tym nie mona wykorzystywa pozostaych 32-bitowych rejestrw oglnego przeznaczenia. Niniejsza wersja adresowania indeksowego jest szczeglnie uyteczna w odwoaniach do skadowych struktur przechowywanych w tablicy (patrz rozdzia 4.).
W omawianym trybie adresowania adres efektywny operandu oblicza si przez dodanie bd
odjcie staej od adresu zmiennej, a nastpnie dodanie wyniku do zawartoci rejestru. Warto
pamita, e to kompilator, a nie procesor, oblicza sum (bd rnic) staej i adresu zmiennej.
Powysze instrukcje s bowiem na poziomie maszynowym implementowane za porednictwem pojedynczej instrukcji, dodajcej pewn warto do rejestru EBX. Z racji podstawiania
przez kompilator w miejsce zmiennej jej staego adresu, instrukcja:
mov( zmienna[ ebx + staa ], al );
redukowana jest do nastpujcej instrukcji:

mov( staa1[ ebx + staa2 ], al );
Ze wzgldu na sposb dziaania trybu adresowania powysza instrukcja jest za rwnowana
nastpujcej:
mov( [ ebx + (staa1 + staa2) ], al );
Obie stae s sumowane na etapie kompilacji, co ostatecznie daje nastpujc instrukcj

maszynow:
mov( [ ebx + suma_staych ], al );
Oczywicie sprawy maj si identycznie rwnie przy odejmowaniu. Rnica pomidzy trybami adresowania z dodawaniem i odejmowaniem staych moe zosta bowiem atwo zniwelowana przy odejmowaniu sta wystarczy obliczy uzupenienie do dwch odejmowanej
staej, i tak otrzyman warto po prostu doda do rejestru dodawanie od odejmowania rni
si wic tylko pojedyncz operacj negacji, rwnie zreszt realizowan na etapie kompilacji.
3.1.2.5. Adresowanie indeksowe skalowane

Tryb adresowania indeksowego skalowanego przypomina zaprezentowane tryby adresowania
indeksowego. Rni si od nich zaledwie dwoma elementami: po pierwsze, w adresowaniu indeksowym skalowanym mona uwika, oprcz wartoci przemieszczenia, zawarto dwch rejestrw;
1 42
Rozdzia 3.
po drugie, tryb adresowania indeksowego skalowanego pozwala na wymnoenie rejestru indeksowego przez wspczynnik (skal) o wartoci 1, 2, 4 bd 8. Skadni tego trybu okrela si
nastpujco:
zmienna[ rejestr-indeksowy32 * skala ]
zmienna[ rejestr-indeksowy32 * skala + przesunicie ]
zmienna[ rejestr-indeksowy32 * skala - przesunicie ]
[ rejestr-bazowy32 + rejestr-indeksowy32 * skala ]
[ rejestr-bazowy32 + rejestr-indeksowy32 * skala + przesunicie ]
[ rejestr-bazowy32 + rejestr-indeksowy32 * skala - przesunicie ]
zmienna[ rejestr-bazowy32 + rejestr-indeksowy32 * skala ]
zmienna[ rejestr-bazowy32 + rejestr-indeksowy32 * skala + przesunicie ]
zmienna[ rejestr-bazowy32 + rejestr-indeksowy32 * skala - przesunicie ]
W powyszych przykadach rejestr-bazowy32 reprezentuje dowolny z 32-bitowych rejestrw

oglnego przeznaczenia, podobnie jak rejestr-indeksowy32 (z puli dostpnych dla tego operandu
rejestrw naley jednak wykluczy rejestr ESP); skala jest sta o wartoci 1, 2, 4 bd 8.
Skalowane adresowanie indeksowe rni si od prostego adresowania indeksowego przede
wszystkim skadow rejestr-indeksowy32 * skala. W trybie tym adres efektywny obliczany jest
przez dodanie wartoci rejestru indeksowego pomnoonej przez wspczynnik skalowania.
Dopiero ta warto wykorzystywana jest w roli indeksu. Sposb obliczania adresu efektywnego
w tym trybie ilustrowany jest rysunkiem 3.6 (w roli rejestru bazowego wystpuje na nim rejestr
EBX; rejestrem indeksowym jest ESI).
Rysunek 3.6. Adresowanie indeksowe skalowane

Jeli dla sytuacji rozrysowanej na rysunku 3.6 przyj, e rejestr EBX zawiera warto $100,
rejestr ESI zawiera warto $20, a zmienna zostaa umieszczona w pamici pod adresem
$2000, wtedy instrukcja:
mov( zmienna[ ebx + esi*4 + 4], al);
1 43
spowoduje skopiowanie do rejestru AL pojedynczego bajta spod adresu $2184 ($2000+

$100+$20*4+4).
Adresowanie indeksowe skalowane przydatne jest w odwoaniach do elementw tablicy,
w ktrej wszystkie elementy maj rozmiary dwch, czterech bd omiu bajtw. Wykorzystuje
si go rwnie w odwoaniach do elementw tablicy, kiedy dany jest wskanik do pocztkowego
elementu tablicy.
3.1.2.6. Adresowanie w piguce

Zapewne Czytelnik bdzie powtpiewa w te sowa, ale wanie pozna kilkaset trybw adresowania! Okazao si to nie takie trudne, prawda? Jeli wci si to Czytelnikowi nie mieci w gowie, powinien wzi pod uwag, e, na przykad, tryb adresowania poredniego przez rejestr
nie jest pojedynczym trybem obejmuje osiem trybw dla omiu rnych rejestrw. Wszystkie
kilkaset trybw powstaje wanie w wyniku kombinacji rejestrw, rozmiarw staych i innych
czynnikw. Tymczasem wystarczy zapozna si z okoo dwudziestoma kilkoma postaciami
odwoa do pamici, aby posugiwa si ca dostpn gam trybw adresowania. W praktyce
zreszt w nawet najbardziej rozbudowanych wykorzystuje si i tak mniej ni poow dostpnych
trybw (wielu nie wykorzystuje si niemal wcale). Okazuje si wic, e opanowanie adresowania pamici nie jest takie trudne.
3.2. Organizacja pamici fazy wykonania

W systemach operacyjnych takich jak Mac OS X, FreeBSD, Linux czy Windows rne rodzaje
danych programw umieszczane s w rnych sekcjach czy te obszarach pamici. Co prawda
przy uruchamianiu programu konsolidujcego mona ingerowa w konfiguracj pamici programu, okrelajc szereg opcji wywoania, ale domylnie programy jzyka HLA w systemie
Windows maj w pamici reprezentacj tak jak na rysunku 3.7 (to samo dotyczy zreszt systemw Linux, Mac OS X i FreeBSD; tam niektre sekcje s jedynie inaczej rozmieszczone).
Rysunek 3.7. Typowe rozmieszczenie elementw programu HLA w pamici
1 44
Rozdzia 3.
Najnisze adresy przestrzeni adresowej programu rezerwowane s przez system operacyjny.

W oglnoci aplikacje nie mog odwoywa si do tego obszaru ani wykonywa w nim instrukcji. Obszar ten suy systemowi operacyjnemu midzy innymi do przechwytywania odwoa
realizowanych za porednictwem wskanikw pustych (NULL). Jeli instrukcja programu
prbuje odwoa si do adresu zerowego (taki adres odpowiada wskanikowi pustemu), system
operacyjny generuje bd ochrony general protection fault sygnalizujcy prb odwoania
do pamici niedostpnej dla programu. Programici czsto inicjalizuj zmienne wskanikowe
wartoci NULL (zerem); warto ta sygnalizuje potem, e wskanik nie wskazuje jeszcze na nic,
a odwoanie za porednictwem takiego wskanika oznacza zazwyczaj bd w programie polegajcy na nieprawidowej inicjalizacji wskanika.
Pozostaych sze obszarw mapy pamici programu to obszary przypisane do poszczeglnych
rodzajw danych. Mamy tu obszar stosu, obszar sterty, obszar kodu, obszar danych niemodyfikowalnych (readonly), obszar zmiennych statycznych oraz obszar pamici niezainicjalizowanej
(storage). Kady z tych obszarw suy do przechowywania okrelonych typw danych deklarowanych w programach jzyka HLA. Zostan one szczegowo omwione w kolejnych punktach.
3.2.1. Obszar kodu

Obszar kodu zawiera instrukcje maszynowe tworzce waciwy program HLA. Kompilator
jzyka HLA tumaczy instrukcje maszynowe kodu rdowego do postaci sekwencji wartoci
jedno- bd kilkubajtowych. Procesor interpretuje owe wartoci jako instrukcje maszynowe (i ich
operandy) i wykonuje je.
Kompilator HLA przez domniemanie podczas konsolidacji programu informuje system operacyjny, e program moe z obszaru kodu czyta instrukcje i dane. Nie moe natomiast zapisywa danych w obszarze kodu. W przypadku prby takiego zapisu system operacyjny wygeneruje
bd ochrony pamici.
Instrukcje maszynowe to po prostu dane bajtowe. Teoretycznie mona by napisa program,
ktry zapisywaby dane w pamici, a nastpnie przekazywa sterowanie do obszaru, w ktrym
dane te zostay zapisane, co daoby efekt samogenerowania programu w czasie jego dziaania.
Moliwo ta skania ku wizji programw inteligentnych, ktre w trakcie dziaania modyfikuj
swj kod, dostosowujc si do postawionego zadania. Niestety, rzeczywisto skrzeczy i o tego
typu efektach na razie nie ma mowy. Zasadniczo programy, ktre same si modyfikuj, s bardzo
trudne do diagnozowania i trudno jest ledzi ich wykonanie, poniewa bez wiedzy programisty
wci modyfikuj kod. Wikszo wspczesnych systemw operacyjnych wrcz utrudnia pisanie modyfikujcych si programw, wic nie bdziemy si wicej nimi zajmowa w tej ksice.
Kompilator jzyka HLA automatycznie umieszcza wszelkie dane zwizane z kodem maszynowym w obszarze kodu. Poza instrukcjami mona w tym obszarze przechowywa rwnie wasne nieetykietowane dane, wykorzystujc do tego nastpujce pseudoinstrukcje4:
Q byte
Q word
Q dword
4
Nie jest to lista pena. Jzyka HLA pozwala w oglnoci na osadzanie w obszarze kodu wartoci
poprzedzanych nazw skalarnego typu danych. Owe typy danych zostan omwione w rozdziale 4.
1 45
Q
Q
Q
Q
Q
Q
Q
Q
uns8
uns16
uns32
int8
int16
int32
boolean
char
Sposb zastosowania powyszych instrukcji ilustruje nastpujca skadnia dla instrukcji byte:
byte lista-oddzielanych-przecinkami-staych-jednobajtowych ;
A oto kilka konkretnych przykadw deklarowania danych nieetykietowanych w obszarze kodu:

boolean
char
byte
byte
word
int8
uns32
true;
'A';
0, 1, 2;
"Ahoj!", 0;
0, 2;
-5;
356789, 0;
Jeli po pseudoinstrukcji pojawi si wicej ni jedna warto staa, kompilator HLA umieszcza
w strumieniu kodu kad z nich po kolei. Std instrukcja byte powoduje wstawienie do tekstu
kodu trzech danych bajtowych, o wartoci odpowiednio: zero, jeden oraz dwa. Jeli po instrukcji
byte pojawia si litera a cuchowy, HLA emituje w jego miejsce cig bajtw, ktrych wartoci
odpowiadaj kodom ASII kolejnych znakw literau. Std druga instrukcja byte powoduje
wstawienie do tekstu kodu piciu bajtw, ktrych wartoci odpowiadaj znakom A, h, o,
j, !, a za nimi pojedynczego bajta o wartoci zero.
Naley jednak pamita, e procesor traktuje dane nieetykietowane osadzone w kodzie tak
jak zwyke instrukcje maszynowe, co wymusza podjcie pewnych krokw zabezpieczajcych
obszary danych przed wykonaniem. Na przykad, jeli programista napisze:
mov( 0, ax );
byte 0, 1, 2, 3;
add( bx, cx );
to w ramach programu nastpi po wykonaniu pierwszej instrukcji mov prba wykonania

wartoci bajtowych 0, 1, 2 oraz 3 jako instrukcji maszynowych. Takie osadzanie danych bajtowych
pomidzy instrukcjami kodu najczciej powoduje bdne dziaanie programu. Dane takie, jeli
ju s umieszczane w obszarze kodu, wymagaj otoczenia ich instrukcjami skoku lub innymi,
uniemoliwiajcymi wykonanie danych jako instrukcji maszynowych.
1 46
Rozdzia 3.
3.2.2. Obszar zmiennych statycznych

Obszar sygnalizowany sowem kluczowym static to domylnie obszar deklarowania zmiennych. Cho sowo kluczowe static moe si pojawi jako cz programu albo procedury, to
naley pamita, e wszelkie deklarowane za t klauzul dane s przez kompilator i tak umieszczane nie w miejscu deklaracji, a w obszarze zmiennych statycznych.
W obszarze zmiennych statycznych mona nie tylko deklarowa zmienne, ale i osadza dane
nieetykietowane. Wykorzystuje si przy tym technik identyczn jak w przypadku osadzania
danych w obszarze kodu: wystarczy poprzedzi warto pseudoinstrukcj byte, word, dword,
uns32 itp. Oto przykad:
static
b:
byte
byte := 0;
1, 2, 3;
u:
uns32 := 1;
uns32 5, 2, 10;
c:
char
char;
'a', 'b', 'c', 'd', 'e', 'f';
bn: boolean;
boolean true;
Dane osadzane w obszarze zmiennych statycznych za porednictwem pseudoinstrukcji s

zapisywane w tym obszarze zawsze za deklarowanymi w nim zmiennymi. Na przykad dane
bajtowe o wartociach 1, 2 oraz 3 zostan umieszczone w obszarze zmiennych statycznych
dopiero za zmienn b inicjalizowan zerem. Poniewa z tak osadzanymi danymi nie s skojarzone adne etykiety, nie mona si do nich odwoywa w kodzie bezporednio jak do innych
zmiennych, mona natomiast wykorzysta adresowanie indeksowe (przykady takich odwoa
zostan zaprezentowane w rozdziale 4.).
W powyszych przykadach zmienne c oraz bn nie s (przynajmniej w sposb jawny) inicjalizowane. Jednak nieokrelenie przez programist wartoci inicjalizujcej nie oznacza, e pozostaj
one niezainicjalizowane kompilator HLA domylnie przyjmuje dla tych zmiennych inicjalizacj zerem polegajc na wyzerowaniu wszystkich bitw zmiennych statycznych; zmienna c
otrzyma wic pocztkow warto NUL (zero odpowiada w zestawie ASCII znakowi pustemu).
W szczeglnoci naley pamita, e deklaracje zmiennych za sowem kluczowym static
powoduj rezerwowanie pamici, nawet jeli do zmiennych nie przypisano adnej wartoci.
3.2.3. Obszar niemodyfikowalny

Obszar danych niemodyfikowalnych przechowuje stae, tablice i inne dane programu, ktre nie
mog w czasie jego wykonania podlega adnym modyfikacjom. Obiekty niemodyfikowalne
deklaruje si w sekcji kodu sygnalizowanej sowem readonly. Sekcja ta ma charakter zbliony
do sekcji static; rni si one trzema waciwociami:
1 47
Q dane obszaru niemodyfikowalnego zapowiadane s w kodzie rdowym sowem

kluczowym readonly, a nie static;
Q wszystkie stae deklarowane w sekcji readonly s inicjalizowane;
Q system nie pozwala na zapisywanie danych w obszarze niemodyfikowalnym w czasie
dziaania programu.
Przykad:
readonly
pi:
e:
MaxU16
MaxI16
real32 := 3.14159;
real32 := 2.71;
uns16 := 65_535;
int16 := 32_767;
Wszystkie deklaracje w sekcji readonly musz by uzupenione o wyraenie inicjalizacji

deklarowanych tu danych nie mona przecie inicjalizowa z poziomu ju dziaajcego programu5.
Obiekty umieszczane w obszarze niemodyfikowalnym mona traktowa jako stae, tyle e
stae te zajmuj pami operacyjn i poza tym, e nie podlegaj operacjom zapisu, zachowuj
si dokadnie tak jak zmienne obszaru zmiennych statycznych. Z tego wzgldu obiektw obszaru
niemodyfikowalnego nie mona wykorzystywa wszdzie tam w programie, gdzie dozwolone
jest zastosowanie staej, czyli gdzie program oczekuje podania literau kodu rdowego. W szczeglnoci obiekty sekcji readonly (traktowane w programach jako stae) nie nadaj si do wykorzystania w roli staych jako operandw instrukcji.
Podobnie jak w obszarze statycznym, w obszarze danych niemodyfikowalnych mona osadza
dane nieetykietowane, poprzedzajc je pseudoinstrukcjami byte, word, dword i tak dalej, jak
poniej:
readonly
roArray:
qwVal:
byte := 0;
byte 1, 2, 3, 4, 5;
qword := 1;
qword 0;
3.2.4. Obszar danych niezainicjalizowanych

W obszarze danych niemodyfikowalnych konieczne jest, z oczywistych wzgldw, inicjalizowanie wszystkich deklarowanych tam obiektw. W obszarze zmiennych statycznych inicjalizacja
jest nieobowizkowa, ale dozwolona (a i tak wszystkie obiekty niezainicjalizowane jawnie s
inicjalizowane zerem). W obszarze danych niezainicjalizowanych, ktrego deklaracje s w kodzie
rdowym programu zapowiadane sowem storage, wszystkie zmienne pozostaj niezainicjalizowane. Zmienne obszaru niezainicjalizowanego deklaruje si nastpujco:
5
Z jednym wyjtkiem opisanym w rozdziale 5.
1 48
Rozdzia 3.
storage
UninitUns32:
i:
character:
b:
uns32;
int32;
char;
byte;
W systemach Linux, FreeBSD, Mac OS X i Windows obszar zmiennych niezainicjalizowanych jest przy adowaniu programu do pamici wypeniany zerami. Nie naley jednak na tej
niejawnej inicjalizacji polega. Jeli w programie niezbdny jest obiekt inicjalizowany wartoci
zerow, to naley zadeklarowa go w obszarze zmiennych statycznych i okreli stosowne wyraenie inicjalizacji.
Zmienne deklarowane w obszarze danych niezainicjalizowanych zajmuj w pliku wykonywalnym programu mniej miejsca ni dane pozostaych omwionych obszarw. Dla tamtych
obszarw plik wykonywalny musi bowiem zawiera wartoci pocztkowe obiektw. W obszarze
danych niezainicjalizowanych jest to zbdne; faktyczna oszczdno miejsca w pliku wykonywalnym jest jednak wasnoci zalen od systemu operacyjnego i przyjtego w nim formatu
obiektowego. Jako e obszar danych niezainicjalizowanych nie moe zawiera wartoci okrelanych statycznie (inicjalizowanych przy deklaracji), nie mona w nim osadza danych nieetykietowanych.
3.2.5. Atrybut @nostorage

Deklarowanie zmiennych w obszarze zmiennych statycznych, obszarze niemodyfikowalnym
i obszarze danych niezainicjalizowanych z atrybutem @nostorage pozwala na opnienie przydziau pamici dla zmiennej a do momentu uruchomienia programu. Atrybut ten instruuje
kompilator, aby ten przypisa do zmiennej adres, ale nie przydziela do niej pamici. Zmienna
ta bdzie dzieli pami z nastpnym obiektem, jaki pojawi si w danej sekcji deklaracji. Oto
skadnia opcji @nostorage:
nazwa-zmiennej: typ; @nostorage;
Nazwa typu jest tu uzupeniana o klauzul @nostorage; nie jest dozwolone okrelenie
wartoci pocztkowej zmiennej bez przydzielonej pamici. Oto przykad zastosowania atrybutu
@nostorage w sekcji readonly:
readonly
abcd: dword; @nostorage;
byte 'a', 'b', 'c', 'd';
W powyszym przykadzie zmienna abcd to podwjne sowo, ktrego najmniej znaczcy

bajt zawiera bdzie warto 97 (a). Bajt pierwszy zawiera bdzie warto 98 (b), bajt
drugi warto 99 (c), a bajt najbardziej znaczcy warto 100 (d). Kompilator HLA nie
1 49
przydziela do zmiennej abcd podwjnego sowa pamici, wic adres zmiennej skojarzony zostanie
z czterema bajtami nieetykietowanymi, alokowanymi w pamici bezporednio za zmienn abcd.
Atrybut @nostorage jest dozwolony jedynie w sekcjach static, storage oraz readonly (czyli
w tak zwanych obszarach deklaracji statycznych). Jzyk HLA nie przewiduje zastosowania
tego atrybutu w sekcji var.
3.2.6. Sekcja deklaracji var

W jzyku HLA oprcz wymienionych wyej dostpna jest te programicie sekcja deklaracji
zapowiadana sowem var, w ramach ktrej tworzone s zmienne automatyczne. Zmienne takie
tworzone s w pamici przy okazji rozpoczcia wykonania pewnej jednostki programu (np.
programu gwnego albo procedury); pami zmiennych automatycznych jest zwalniana przy
wychodzeniu z procedury czy programu. Naturalnie wszelkie zmienne automatyczne deklarowane w programie gwnym charakteryzuj si czasem ycia6 identycznym z czasem ycia
obiektw sekcji static, storage oraz readonly dla zmiennych automatycznych programu
gwnego ich podstawowa cecha jest znoszona. W oglnoci zastosowanie tych zmiennych ma
wic sens wycznie w procedurach (patrz rozdzia 5.). Mimo to jzyk HLA dopuszcza deklarowanie zmiennych automatycznych rwnie w ramach programu gwnego.
Pami dla zmiennych deklarowanych w sekcji var przydzielana jest w czasie dziaania programu (w tzw. fazie wykonania), wic kompilator nie moe samodzielnie ich inicjalizowa. Z tego
wzgldu skadnia obowizujca w deklaracjach umieszczanych za sowem var zbliona jest do
tej znanej z deklaracji zmiennych obszaru niemodyfikowalnego. Jedyn istotn rnic skadniow
pomidzy tymi sekcjami jest zastosowanie sowa kluczowego var w miejsce storage7:
var
vInt:
vChar:
int32;
char;
HLA przydziela pami dla zmiennych deklarowanych w sekcji var w obszarze stosu programu. Kompilator nie moe przy tym okreli dokadnego adresu owych zmiennych. Zamiast
tego zmienne s alokowane w ramach rekordu aktywacji skojarzonego z biec jednostk
programu. Omwienie rekordw aktywacji znajduje si w rozdziale 5.; na razie Czytelnik powinien zapamita, e w programach jzyka HLA wskanik na biecy rekord aktywacji przechowywany jest w rejestrze EBP. Kiedy wic w programie nastpuje odwoanie do obiektu
deklarowanego w sekcji var, nazwa zmiennej wystpujca w odwoaniu jest automatycznie
zastpowana przez kompilator konstrukcj [EBP przesunicie]. Przesunicie jest przy tym
przesuniciem obiektu w ramach rekordu aktywacji. Oznacza to, e w programach HLA nie
mona wykorzystywa w peni trybu adresowania indeksowego skalowanego (gdzie adres efektywny okrelany jest wartoci rejestru bazowego i iloczynem skali i wartoci rejestru indek6
Czas ycie zmiennej to okres, jaki upywa od momentu przydzielenia dla niej pamici do momentu
zwolnienia tej pamici.
Jest te kilka rnic pomniejszych, ktre nie bd jednak omawiane w ksice; zainteresowanych
Czytelnikw odsyam do dokumentacji jzyka HLA.
1 50
Rozdzia 3.
sowego), poniewa rejestr EBP zarezerwowany jest w programach HLA dla rekordu aktywacji.
I cho adresowania indeksowego skalowanego nie wykorzystuje si tak czsto, to ju sam fakt,
e nie da si go w peni wykorzysta w obecnoci sekcji var, powinien stanowi wystarczajcy
powd, aby unika stosowania tej sekcji w programie gwnym.
3.2.7. Rozmieszczenie sekcji deklaracji danych

w programie HLA
Sekcje zapowiadane sowami static, storage, readonly oraz var mog wystpowa w programie HLA zero albo wicej razy, wystpujc pomidzy nagwkiem program, a odpowiadajc
programowi klauzul begin. Pomidzy tymi punktami sekcje deklaracji danych mog wystpowa w dowolnej kolejnoci, co ilustruje poniszy przykad:
program demoDeclarations;
static
i_static:
int32;
var
i_auto:
int32;
storage
i_uninit:
int32;
readonly
i_readonly:
int32 := 5;
static
j:
uns32;
var
k:
char;
readonly
i2:
uns8 := 9;
storage
c:
char;
storage
d:
dword;
begin demoDeclarations;
// kod programu
end demoDeclarations;
1 51
Powyszy przykad, oprcz moliwoci dowolnego porzdkowania poszczeglnych sekcji

deklaracji danych, demonstruje te moliwo wystpowania w programie danej sekcji wielokrotnie. W przypadku obecnoci w kodzie wielokrotnych deklaracji tej samej kategorii (tu mamy
na przykad trzykrotnie okrelon sekcj storage), poszczeglne sekcje deklaracji s przez
kompilator konsolidowane do postaci pojedynczej sekcji.
3.3. Przydzia pamici dla zmiennych

w programach HLA
Czytelnik orientuje si ju, e procesor nie odwouje si do zmiennych przez ich nazwy, na
przykad I, Profits czy LineCnt. Procesor moe operowa jedynie wartociami liczbowymi reprezentujcymi adresy, tylko takie wartoci nadaj si bowiem do wysterowania szyny adresowej.
Procesor nie rozrnia wic nazw, a adresy, jak $1234_5678, $0400_1000 czy $8000_CC00. Z drugiej strony jzyk HLA pozwala programicie na wykorzystywanie zamiast adresw zmiennych
(co byoby cokolwiek uciliwe adresy, w przeciwie stwie do nazw, s trudne do zapamitania) ich nazw. Moliwo przydatna, ale o tyle niedobra, e zastosowanie nazw powoduje ukrycie
faktycznego sposobu realizacji odwoa . W niniejszym podrozdziale przyjrzymy si wic sposobowi, w jaki kompilator HLA przypisuje adresy do zmiennych, tak aby Czytelnik wci
posugujc si wygodnymi nazwami, a nie adresami mia pene wyobraenie o tym, co kryje
si za nazw zmiennej.
Spjrzmy ponownie na rysunek 3.7. Wida na nim, e poszczeglne obszary pamici ssiaduj ze sob. Z tego wzgldu zmiana rozmiaru jednego z obszarw powoduje zmian adresw
bazowych wszystkich pozostaych obszarw pamici. Na przykad, jeli program zostanie uzupeniony kilkoma choby instrukcjami maszynowymi, spowoduje to zwikszenie rozmiaru obszaru
kodu, co z kolei moe wymusi zmian adresu bazowego obszaru zmiennych statycznych, co
w efekcie prowadzi do zmiany adresw wszystkich zadeklarowanych w programie zmiennych
statycznych. Rozrnianie zmiennych na podstawie ich adresw jest i tak dla programisty zadaniem ponad siy; gdyby jeszcze musia uwzgldnia ich przemieszczenie w wyniku najdrobniejszych nawet modyfikacji kodu, to zapewne oszalaby z przepracowania. Na szczcie programist w tym niewdzicznym zadaniu wyrcza kompilator.
W jzyku HLA z kad z trzech sekcji deklaracji statycznych (czyli sekcj static, readonly
oraz storage) skojarzony jest licznik lokacji. Pocztkowo liczniki owe zawieraj wartoci zero;
w momencie zadeklarowania zmiennej w jednej z sekcji deklaracji statycznych HLA kojarzy
z t zmienn biec warto licznika lokacji (otrzymujc adres zmiennej), a sam licznik jest
zwikszany o rozmiar deklarowanego obiektu. W ramach przykadu zamy, e ponisza sekcja
jest jedyn sekcj static w programie:
static
b:
byte;
// licznik lokacji = 0, rozmiar obiektu = 1;
w:
word;
d:
dword;
q:
qword;
l:
lword;
// Bieca warto licznika lokacji to 31.
1 52
Rozdzia 3.
Rzecz jasna w fazie wykonania programu adresy wszystkich tych zmiennych nie bd odpowiaday wartociom licznika lokacji. Wszystkie one zostan po pierwsze zwikszone o adres
bazowy obszaru zmiennych statycznych, a po drugie, jeli w innym module konsolidowanym
z programem (na przykad w module biblioteki standardowej HLA) wystpuj kolejne sekcje
deklaracji static albo kolejne takie sekcje wystpuj w tym samym pliku rdowym, konsolidator musi scali obszary zmiennych statycznych. Z tego wzgldu ostateczne adresy zmiennych
statycznych mog si nieco rni od tych obliczonych przez proste przemieszczenie adresu
bazowego obszaru statycznego o warto licznika lokacji.
Nie zmienia to jednak zasadniczej waciwoci mechanizmu przydziau pamici do zmiennych statycznych, czyli tego, e s one przydzielane w cigym obszarze pamici jedna za
drug. Wracajc do przykadu: zmienna b bdzie okupowaa pami przylegajc bezporednio do pamici przydzielonej do zmiennej d, ktra bdzie ssiadowa w pamici ze zmienn w
i tak dalej. Co prawda w przypadku oglnym nie naley zakada takiego wanie, ssiadujcego
rozmieszczenia zmiennych w pamici, ale niekiedy zaoenie takie jest bardzo wygodne.
Naley przy tym pamita, e zmienne deklarowane w sekcjach readonly, static oraz storage
okupuj zupenie odrbne obszary pamici. Std nie wolno zakada, e deklarowane poniej
trzy obiekty bd ze sob ssiadowa w pamici programu:
static
b
:byte;
readonly
w
:word := $1234;
storage
d
:dword;
W rzeczy samej kompilator HLA nie gwarantuje nawet, e zmienne tego samego obszaru
pamici, ale deklarowane w osobnych sekcjach deklaracji, bd ze sob ssiadowa, nawet jeli
w kodzie rdowym sekcji tych nie rozdziela adna inna sekcja deklaracji. Std nie wolno zakada, e w wyniku kompilacji poniszych deklaracji zmienne b, d i w bd w obszarze pamici
zmiennych statycznych rozmieszczone ssiadujco w tej wanie kolejnoci; nie wolno nawet
zakada, e w ogle zostan rozmieszczone ssiadujco:
static
b
static
w
static
d
:byte;
:word := $1234;
:dword;
Jeli konstrukcja programu wymaga, aby owe zmienne okupoway ssiadujce komrki
pamici, naley umieci je we wsplnej sekcji deklaracji.
Deklaracje zmiennych automatycznych w sekcji var s obsugiwane nieco inaczej ni zmienne
sekcji deklaracji statycznych. Sposb przydzielania pamici do tych zmiennych zostanie omwiony w rozdziale 5.
1 53
3.4. Wyrwnanie danych w programach HLA

Aby programy dziaay szybciej, naley obiekty danych odpowiednio rozmieszcza w pamici;
w szczeglnoci istotne jest wyrwnanie obiektw. Odpowiednie wyrwnanie objawia si tym,
e adres bazowy danego obiektu jest cakowit wielokrotnoci pewnego rozmiaru, zwykle rozmiaru tego obiektu, jeli mieci si on w 16 bajtach. Dla obiektw wikszych od 16-bajtowych
stosuje si wyrwnanie omiobajtowe albo szesnastobajtowe. Dla obiektw mniejszych stosuje
si wyrwnanie do adresw bdcych wielokrotnociami takiej potgi liczby dwa, ktra daje
rozmiar wikszy od rozmiaru obiektu. Odwoania do danych niewyrwnanych do odpowiednich
adresw mog wymaga dodatkowego czasu procesora, wic gwoli zapewnienia maksymalnej
szybkoci dziaania programu warto pamita o odpowiednim wyrwnywaniu danych w pamici.
Wyrwnanie danych jest tracone, kiedy w ssiadujcych ze sob komrkach pamici alokowane s obiekty o rnych rozmiarach. Na przykad dla zmiennej o rozmiarze bajta przydzielona
zostanie pami o rozmiarze jednego bajta. Nastpna zmienna, deklarowana w danej sekcji
deklaracji, otrzyma adres rwny adresowi owego bajta zwikszony o jeden. Jeli zdarzyoby si,
e w bajt zosta umieszczony w pamici pod adresem parzystym, zmienna ssiadujca z bajtem
bdzie si rzeczy mie adres nieparzysty; jeli bdzie to sowo bd podwjne sowo, adres
taki nie bdzie optymalny. Std konieczno znajomoci sposobw wymuszania odpowiedniego
wyrwnania obiektw.
Niech w programie HLA okrelone zostan nastpujce deklaracje statyczne:
static
dw:
b:
w:
dw2:
w2:
b2:
dw3:
dword;
byte;
word;
dword;
word;
byte;
dword;
Pierwsza z deklaracji statycznych w programie (przy zaoeniu, e program ten bdzie dziaa
pod kontrol systemu operacyjnego Windows, Mac OS X, FreeBSD, Linux lub innego systemu
32-bitowego) zostanie umieszczona pod adresem o parzystej wartoci bdcej przy tym wielokrotnoci liczby 4096. Std pierwsza zmienna w sekcji deklaracji, niezalenie od jej typu,
zostanie optymalnie wyrwnana. Kolejne zmienne s jednak umieszczane pod adresami liczonymi jako suma adresu bazowego obszaru pamici i rozmiarw wszystkich poprzednich zmiennych. Jeli wic zaoy, e deklarowane powyej zmienne zostan po kompilacji w obszarze
pamici rozpoczynajcym si od adresu 4096, to poszczeglne zmienne otrzymaj nastpujce
adresy:
dw:
b:
w:
dw2:
w2:
1 54
dword;
byte;
word;
dword;
word;
Rozdzia 3.
// adres pocztkowy
// 4096
// 4100
// 4101
// 4103
// 4107
rozmiar
4
1
2
4
2
b2:
dw3:
byte;
dword;
// 4109
// 4110
1
4
Z wyjtkiem zmiennej pierwszej (wyrwnanej do adresu 4096) oraz zmiennej bajtowej b2

(wyrwnanie zmiennych bajtowych jest zawsze dobre) wszystkie zmienne s tu wyrwnane
nieoptymalnie. Zmienne w, w2 oraz dw2 rozmieszczone zostay pod nieparzystymi adresami;
zmienna dw3 zostaa wyrwnana do adresu parzystego, ale niebdcego, niestety, wielokrotnoci
czwrki.
Najprostszym sposobem zagwarantowania odpowiedniego wyrwnania wszystkich zmiennych jest zadeklarowanie jako pierwszych wszystkich obiektw o rozmiarze podwjnego sowa,
a za nimi wszystkich obiektw o rozmiarze sowa; obiekty jednobajtowe powinny by deklarowane na ko cu, jak poniej:
static
dw:
dw2:
dw3:
w:
w2:
b:
b2:
dword;
dword;
dword;
word;
word;
byte;
byte;
Takie uoenie deklaracji owocuje rozmieszczeniem zmiennych pod nastpujcymi adresami (przyjmujemy, e adresem bazowym obszaru zmiennych statycznych jest 4096):
dw:
dw2:
dw3:
w:
w2:
b:
b2:
dword;
dword;
dword;
word;
word;
byte;
byte;
// adres pocztkowy
// 4096
// 4100
// 4104
// 4108
// 4110
// 4112
// 4113
rozmiar
4
4
4
2
2
1
1
Jak wida, wyrwnanie poszczeglnych zmiennych jest ju zgodne z reguami sztuki.
Niestety, bardzo rzadko moliwe jest takie uoenie zmiennych programu. Niemono kadorazowego optymalnego uoenia zmiennych wynika z szeregu przyczyn technicznych; w praktyce wystarczajc przyczyn jest brak logicznego powizania deklaracji zmiennych, jeli te s
ukadane wycznie ze wzgldu na rozmiar obiektu; tymczasem dla przejrzystoci kodu rdowego niektre zmienne naley grupowa niezalenie od ich rozmiarw.
Rozwizaniem tego konfliktu interesw jest dyrektywa align jzyka HLA. Skadnia dyrektywy prezentuje si nastpujco:
align( staa-cakowita );
1 55
Staa cakowita okrelona w argumencie dyrektywy moe by jedn z nastpujcych wartoci: 1, 2, 4, 8 lub 16. Jeli w sekcji deklaracji za sowem static kompilator HLA napotka dyrektyw align, nastpna deklarowana w sekcji zmienna zostanie wyrwnana do adresu bdcego
cakowit wielokrotnoci argumentu dyrektywy. Analizowany przez nas przykad mona z wykorzystaniem dyrektywy align przepisa nastpujco:
static
align(
dw:
b:
align(
w:
align(
dw2:
w2:
b2:
align(
dw3:
4 );
dword;
byte;
2 );
word;
4 );
dword;
word;
byte;
4 );
dword;
Jak dziaa dyrektywa align? To cakiem proste. Jeli kompilator wykryje, e biecy adres
(czyli bieca warto licznika lokacji) nie jest cakowit wielokrotnoci wartoci okrelonej
argumentem dyrektywy, wprowadza do obszaru pamici szereg bajtw danych nieetykietowanych (bajtw wyrwnania), uzupeniajc nimi poprzedni deklaracj, tak aby bieca warto
licznika lokacji osigna podan warto. Program staje si przez to nieco wikszy (o dosownie kilka bajtw), ale w zamian dostp do danych programu jest nieco szybszy; jeli faktycznie
zwikszenie rozmiaru programu miaoby si ograniczy do kilku dodatkowych bajtw, wymiana
ta byaby bardzo atrakcyjna.
Warto przyj regu, e w celem maksymalizowania szybkoci odwoa do obiektw danych
naley je wyrwnywa do adresw bdcych cakowitymi wielokrotnociami ich rozmiaru.
Sowa powinny wic by wyrwnywane do parzystych adresw pamici (align(2);), podwjne
sowa do adresw podzielnych bez reszty przez cztery (align(4);), sowa poczwrne naley
wyrwnywa do adresw podzielnych przez osiem i tak dalej. Jeli rozmiar obiektu nie jest
rwny potdze dwjki, naley wyrwna go do adresw podzielnych przez potg dwjki najblisz jego rozmiarowi, lecz od niego wiksz. Wyjtkiem s obiekty typu real80 oraz tbyte,
ktre naley wyrwnywa do adresw podzielnych przez osiem.
Wyrwnywanie danych nie zawsze jest konieczne. Architektura pamici podrcznej wspczesnych procesorw z rodziny 80x86 pozwala bowiem na efektywn (w wikszoci przypadkw) obsug rwnie danych niewyrwnanych. Dyrektywy wyrwnania powinny wic by
stosowane wycznie wobec tych danych, w przypadku ktrych szybko dostpu ma zasadnicze
znaczenie dla wydajnoci programu. W przypadku takich zmiennych ewentualny koszt optymalizacji dostpu w postaci kilku dodatkowych bajtw programu bdzie z pewnoci do przyjcia.
1 56
Rozdzia 3.
3.5. Wyraenia adresowe

Prezentowane w poprzednich podrozdziaach tryby adresowania ilustrowane byy kilkoma
postaciami odwoa , w tym:
zmienna[
zmienna[
zmienna[
zmienna[
zmienna[
zmienna[
rejestr32 ];
rejestr32 + przesunicie ];
rejestr32-nie-ESP * skala ];
rejestr32 + rejestr32-nie-ESP * skala ];
rejestr32-nie-ESP * skala + przesunicie ];
rejestr32 + rejestr32-nie-ESP * skala + przesunicie ];
Istnieje jeszcze jedna forma odwoania, niewprowadzajca nowego trybu adresowania,

a bdca jedynie rozszerzeniem trybu adresowania bezporedniego:
zmienna[ przesunicie ]
W tej ostatniej postaci odwoania adres efektywny obliczany jest przez dodanie staego
przesunicia okrelonego wewntrz nawiasw prostoktnych do adresu zmiennej. Na przykad
instrukcja mov(adres[3], al) powoduje zaadowanie rejestru AL wartoci znajdujc si
w pamici pod adresem odlegym o trzy bajty od adresu zmiennej adres (patrz rysunek 3.8).
Rysunek 3.8. Wyraenie adresowe w odwoaniu do danej umieszczonej za zmienn

Warto przesunicia musi by wyraona jako staa, czyli litera liczbowy. Jeli, na przykad,
zmienna i jest zmienn typu int32, wtedy wyraenie zmienna[i] nie jest dozwolonym wyraeniem adresowym. Aby odwoywa si do danych za porednictwem indeksu dynamicznego
modyfikowanego w trakcie dziaania programu, naley skorzysta z trybu adresowania indeksowego, ewentualnie indeksowego skalowanego.
1 57
Kolejnym wanym spostrzeeniem jest to, e przesunicie w wyraeniu adres[przesunicie]

jest adresem bajtowym. Mimo e skadnia wyraenia adresowego przypomina t znan z jzykw C, C++ i Pascal, to tutaj przesunicie nie stanowi indeksu w sensie licznika elementw
tablicy chyba e adres jest tablic bajtw.
W niniejszej ksice wyraeniem adresowym bdzie dowolny z trybw adresowania procesora 80x86, ktry obejmuje przemieszczenie (na przykad zawiera nazw zmiennej) albo przesunicie. Za poprawne wyraenia adresowe bd take uwaane nastpujce odwoania:
[ rejestr32 + przesunicie ]
[ rejestr32 + rejestr-nieESP32 * skala + przesunicie ]
Natomiast ponisze wyraenia nie bd uznawane za poprawne wyraenie adresowe, jako
e nie angauj ani przemieszczenia, ani przesunicia:
[ rejestr32 ]
[ rejestr32 + rejestr-nieESP32 * skala ]
Wyraenia adresowe s o tyle szczeglne, e instrukcje zawierajce wyraenia adresowe

zawsze koduj sta przemieszczenia jako skadow instrukcji maszynowej. Oznacza to, e
struktura instrukcji maszynowej przewiduje pewn liczb bitw (zwykle 8 bd 32) dla wartoci staej okrelajcej przemieszczenie. Staa ta obliczana jest jako suma okrelonego w kodzie
przemieszczenia (czyli np. adresu zmiennej wzgldem adresu bazowego) oraz ewentualnego
przesunicia. Kompilator automatycznie sumuje te wartoci (albo je odejmuje, kiedy w wyraeniu adresowym w miejsce plusa wystpuje minus).
Jak dotychczas przesunicie we wszystkich przykadach adresowania reprezentowane byo
pojedyncz sta liczbow literaem liczbowym. Tymczasem w jzyku HLA wszdzie tam,
gdzie powinno zosta okrelone przesunicie, dopuszczalne jest stosowanie wyrae staowartociowych. Wyraenie staowartociowe skada si z jednego lub kilku skadowych bdcych
staymi czonych za porednictwem operatorw takich jak operatory dodawania, odejmowania,
dzielenia i mnoenia, operator modulo i szeregu innych operatorw. Wemy nastpujcy przykad:
mov( x[ 2*4 + 1], al );
Powysza instrukcja spowoduje skopiowanie pojedynczego bajta spod adresu X+9 do rejestru AL.
Warto wyraenia adresowego jest zawsze obliczana w czasie kompilacji, nigdy w fazie
wykonania programu. Kiedy kompilator HLA napotka w kodzie rdowym wyraenie podobne
do prezentowanego wyej, oblicza warto 2*4+1 i dodaje otrzymany rezultat do bazowego
adresu zmiennej X w pamici. Cao przemieszczenia, na ktr skada si przemieszczenie
zmiennej X wzgldem adresu bazowego oraz przesunicie 2*4+1, kodowane jest nastpnie
w instrukcji maszynowej, co znakomicie zmniejsza nakady czasowe potrzebne do ustalenia
adresu efektywnego w fazie wykonania. Obliczanie wyrae adresowych w czasie kompilacji
1 58
Rozdzia 3.
nakada na wszystkie skadowe wyraenia staowartociowego wymg okrelonoci wartoci

podczas kompilacji kompilator nie jest w stanie przewidzie wartoci zmiennej w czasie
wykonania programu, std w wyraeniach adresowych nie mog by wykorzystywane zmienne.
Wyraenia adresowe przydaj si w odwoaniach do danych znajdujcych si w pamici
poza zasigiem zmiennej, na przykad do zmiennych nieetykietowanych wprowadzanych do
kodu bd obszarw danych pseudoinstrukcjami byte, word, dword i im podobnymi. Rozwamy,
na przykad, program z listingu 3.1.
Listing 3.1. Przykad zastosowania wyraenia adresowego
program adrsExpressions;
#include( "stdlib.hhf" );
static
i: int8; @nostorage;
byte 0, 1, 2, 3;
begin adrsExpressions;
stdout.put
(
"i[0]=",
"i[1]=",
"i[2]=",
"i[3]=",
);
i[0],
i[1],
i[2],
i[3],
nl,
nl,
nl,
nl
end adrsExpressions;
Uruchomienie programu z listingu 3.1 spowoduje wyprowadzenie na wyjcie wartoci 0,

1, 2 oraz 3, zupenie tak, jakby byy one kolejnymi elementami tablicy. Jest to moliwe dziki
temu, e pod adresem zmiennej i umieszczony zosta nieetykietowany bajt o wartoci zero.
Zmienna i zostaa bowiem zadeklarowana z atrybutem @nostorage, co oznacza, e jej adres ma
si pokrywa z adresem nastpnego zadeklarowanego w danej sekcji obiektu. W naszym przykadzie obiektem tym jest akurat nieetykietowany bajt danych o wartoci 0. Dalej, wyraenie
adresowe i[1] jest przez kompilator HLA realizowane jako instrukcja pobrania bajta znajdujcego si pod adresem odlegym o jeden bajt od adresu zmiennej i. Tam z kolei znajduje si
nieetykietowany bajt o wartoci 1. Analogicznie dla wyrae i[2] oraz i[3] program wyprowadza
wartoci dwch pozostaych nieetykietowanych bajtw.
3.6. Koercja typw

Cho jzyk HLA nie szczyci si szczeglnie cis kontrol typw, kompilator tego jzyka potrafi
wymusi na programicie przynajmniej zastosowanie w danej instrukcji operandw o odpowiednich rozmiarach. Wemy na przykad nastpujcy, celowo niepoprawny program:
1 59
program hasErrors;
static
i8:
int8;
i16: int16;
i32: int32;
begin hasErros;
mov( i8, eax );
mov( i16, al );
mov( i32, ax );
end hasErrors;
Kompilacja programu zako czy si zgoszeniem bdu kompilacji wszystkich trzech konstytuujcych program instrukcji mov. Przyczyn bdw jest naturalnie niezgodno rozmiarw
operandw. W pierwszej instrukcji nastpuje prba zaadowania 32-bitowego rejestru EAX
wartoci 8-bitowej zmiennej; w drugiej instrukcji programista prbuje zaadowa 8-bitowy
rejestr AL wartoci 16-bitow, a w trzeciej rejestr 16-bitowy AX ma by zaadowany wartoci
32-bitow. Tymczasem instrukcja mov nakada na operandy wymg identycznoci rozmiarw.
Niewtpliwie tego rodzaju kontrola typw jest zalet jzyka HLA8, niekiedy jednak zaczyna
programicie przeszkadza. Na przykad w poniszym fragmencie kodu:
static
byte_values:
byte; @nostorage;
byte 0, 1;
mov( byte_values, ax );
W tym przykadzie programista faktycznie zamierza zaadowa 16-bitowy rejestr 16-bitowym sowem, ktrego adres jest identyczny z adresem zmiennej 8-bitowej byte_values. Rejestr
AL miaby by zaadowany wartoci 0, a rejestr AH wartoci 1 (zauwamy, e w mniej znaczcym bajcie pamici zmiennej przechowywane jest 0, a w bardziej znaczcym bajcie pamici 1).
Niestety, kompilator HLA zablokuje tego rodzaju prb, podejrzewajc bd niezgodnoci
rozmiarw operandw (w ko cu zmienna byte_values to zmienna 8-bitowa, a rejestr AX ma
16 bitw). Programista moe obej przeszkod, adujc rejestr dwoma instrukcjami maszynowymi: jedn adujca rejestr AL bajtem spod adresu zmiennej byte_values i drug adujc
rejestr AH wartoci nastpnego bajta, byte_values[1]. Niestety, taka dekompozycja instrukcji
powoduje zmniejszenie wydajnoci programu (a najprawdopodobniej wanie troska o t wydajno zmusia programist do umieszczenia w kodzie tak karkoomnej jak zaprezentowana kon-
W ko cu niezgodno rozmiarw operandw jest najczciej efektem nieuwagi programisty.
1 60
Rozdzia 3.
strukcji). Byoby wic podane, aby dao si poinstruowa kompilator o zamiarze dotrzymania
wymogu zgodnoci rozmiarw i e adres zmiennej byte_values ma by interpretowany jako
adres nie bajta, a sowa. Moliwo t daje koercja typw.
Koercja typw9 to proces, w ramach ktrego kompilator HLA informowany jest o tym, e
dany obiekt bdzie traktowany jako obiekt typu okrelonego wprost w kodzie, niekoniecznie
zgodnego z typem podanym w deklaracji. Skadnia koercji typu zmiennej wyglda nastpujco:
(type nowa-nazwa-typu wyraenie-adresowe)
Nowa nazwa typu okrela typ docelowy koercji, ktry ma zosta skojarzony z adresem pamici
wyznaczanym wyraeniem adresowym. Operator koercji moe by wykorzystywany wszdzie
tam, gdzie dozwolone jest okrelenie adresu w pamici. Znajc koercj typw, mona poprawi
poprzedni przykad, tak aby da si skompilowa bez bdw:
mov( (type word byte_values), ax);
Powysza instrukcja nakazuje zaadowanie rejestru AX wartoci sowa rozpoczynajcego

si pod adresem byte_values. Jeli zaoy, e pod adresem tym nadal znajduj si wartoci
bajtw nieetykietowanych prezentowanych w przykadzie, rejestr AL zostanie zaadowany wartoci zero, a AH wartoci jeden.
Koercja typw jest koniecznoci, kiedy w roli operandu instrukcji bezporednio modyfikujcej pami (a wic instrukcji neg, shl, not i im podobnym) ma wystpi zmienna anonimowa. Rozwamy nastpujcy przykad:
not( [ebx] );
Instrukcji takiej nie da si skompilowa, poniewa nie sposb na jej podstawie okreli rozmiaru operandu docelowego. Kompilator nie ma wic wystarczajcych informacji do skonstruowania kodu instrukcji maszynowej nie wie, czy program ma dokona inwersji bitw pojedynczego bajta wskazywanego zawartoci rejestru EBX, czy moe caego znajdujcego si
pod tym adresem sowa albo i podwjnego sowa. Aby okreli rozmiar operandu niezbdny do
zakodowania instrukcji maszynowej, naley wykona koercj typu odwoania do zmiennej anonimowej, jak w poniszych instrukcjach:
not( (type byte [ebx]) );
not( (type dword [ebx]) );
W niektrych innych jzykach identyczny proces nosi nazw rzutowania.
1 61
Ostrzeenie
Nie wolno wykorzystywa koercji typw na chybi trafi, bez penej wiadomoci skutkw, jakie
koercja przyniesie. Pocztkujcy programici jzyka asemblerowego czsto korzystaj z koercji
typw jako rodka uciszania kompilatora, kiedy ten zwraca nie do ko ca dla nich zrozumiae
komunikaty o bdach niezgodnoci typw.
Przykadem niepoprawnej koercji moe by nastpujca instrukcja (zakadamy, e byteVar
to zmienna jednobajtowa):
mov( eax, (type dword byteVar) );
Gdyby nie koercja typw, kompilator odmwiby kompilacji kodu ze wzgldu na niedopasowanie rozmiarw operandw instrukcji mov. Nastpuje tu bowiem prba skopiowania
32-bitowej zawartoci rejestru do zmiennej jednobajtowej. Jeli koercja zostaa przez pocztkujcego programist zastosowana wycznie celem uciszenia kompilatora, to niewtpliwie cel ten
zostanie osignity kompilator nie bdzie ju ostrzega o niedopasowaniu typw. Program
moe by jednak mimo bezbdnej kompilacji niepoprawny. Operator koercji nie eliminuje
bowiem rda potencjalnego problemu, jakim jest prba umieszczenia wartoci 32-bitowej
w zmiennej 8-bitowej. Prba taka musi zako czy si po prostu umieszczeniem czterech bajtw
w pamici, poczynajc od adresu zmiennej byteVar. Tak wic trzy bajty kopiowane z rejestru
nadpisz wartoci trzech bajtw ssiadujcych w pamici ze zmienn byteVar. Bdy tego rodzaju
czsto objawiaj si nieoczekiwanymi, tajemniczymi modyfikacjami zmiennych programu10,
albo, gorzej, prowokuj bd ochrony pamici. Ten ostatni moe wystpi, jeli na przykad
jeden z trjki bajtw ssiadujcych ze zmienn byteVar bdzie ju nalee do obszaru pamici
niemodyfikowalnej. Warto wic w odniesieniu do stosowania operatora koercji przyj nastpujc regu: jeli nie wiadomo dokadnie, jaki wpyw na dziaanie programu ma zastosowanie
operatora koercji, stosowa go po prostu nie naley.
Nie wolno zapomina, e operator koercji typw nie realizuje adnej translacji czy konwersji danych przechowywanych w obiekcie, do ktrego odwoanie zostao poddane dziaaniu
operatora. Operator ten ma wpyw jedynie na dziaanie kompilatora, instruujc go co do sposobu interpretowania rozmiaru operandu. W szczeglnoci, koercja wartoci jednobajtowej ze
znakiem do rozmiaru trzydziestu dwch bitw nie spowoduje automatycznego rozszerzenia
znakiem ani te koercja do typu zmiennoprzecinkowego nie spowoduje konwersji obiektu do
postaci zmiennoprzecinkowej.
3.7. Koercja typu rejestru

Za porednictwem operatora koercji mona te wykona rzutowanie rejestru na okrelony typ.
Domylnie bowiem rejestry 8-bitowe s w jzyku HLA obiektami typu byte, rejestry 16-bitowe
maj przypisany typ word, a rejestry 32-bitowe to obiekty typu dword. Przy uyciu operatora
10
Jeli bezporednio za zmienn byteVar w pamici programu znajduje si inna zmienna, jej warto
zostanie w wyniku wykonania instrukcji mov na pewno nadpisana, niezalenie od tego, czy jest to efekt
przewidziany i podany przez programist.
1 62
Rozdzia 3.
koercji mona interpretacj typu rejestru zmienia pod warunkiem, e typ docelowy bdzie
identycznego rozmiaru co rozmiar rejestru. Koercja typu rejestru nie ma wikszego zastosowania, jednak czasem trudno si bez niej obej. Jedn z sytuacji, w ktrych si ona przydaje,
jest konstruowanie wyrae logicznych w wysokopoziomowych instrukcjach jzyka HLA (jak
if czy while) i przekazywanie zawartoci rejestrw do procedur wejcia-wyjcia, gdzie koercja
umoliwia odpowiedni interpretacj tej zawartoci.
W wyraeniach logicznych jzyka HLA obiekty typu byte, word i dword interpretowane s
zawsze jako wartoci bez znaku. Std bez koercji typu rejestru ponisza instrukcja if miaaby
zawsze warto false (trudno bowiem, aby warto bez znaku bya mniejsza od zera):
if( eax < 0 ) then
stdout.put( "Wartosc rejestru EAX jest ujemna!", nl );
endif;
Sabo t mona wyeliminowa, stosujc w wyraeniu logicznym instrukcji if koercj typu

rejestru:
if( (type int32 eax) < 0 ) then
stdout.put( "Wartosc rejestru EAX jest ujemna!", nl );
endif;
Na podobnej zasadzie wartoci typu byte, word oraz dword s przez procedur stdout.put
interpretowane jako liczby szesnastkowe. Jeli wic zachodzi potrzeba wywietlenia zawartoci
rejestru, to jego przekazanie wprost do procedury wyjcia stdout.put spowoduje wyprowadzenie jego wartoci w zapisie szesnastkowym. Jeli programista chce wymusi inn interpretacj
zawartoci rejestru, musi skorzysta z koercji typu rejestru:
stdout.put( "AL interpretowany jako znak = '", (type char AL), "'", nl );
Identyczn rol peni koercja typu rejestru w wywoaniach procedur wejciowych jak
stdin.get. Ta procedura bowiem, jeli argument okrela operand docelowy jako operand typu
byte, word bd dword, interpretuje wprowadzane dane jako wartoci szesnastkowe; niekiedy
zachodzi wic konieczno dokonania koercji typu rejestru.
1 63
3.8. Pami obszaru stosu

oraz instrukcje push i pop
Wczeniej w rozdziale wspomniano, e wszystkie zmienne deklarowane w sekcji var lduj
w obszarze pamici zwanym obszarem stosu. Jednak obszar stosu nie suy wycznie do przechowywania obiektw automatycznych pami stosu wykorzystywana jest do wielu rnych
celw i na wiele sposobw. W niniejszym podrozdziale poznamy stos procesora, zaprezentowane
zostan te dwie z instrukcji sucych do manipulowania danymi na stosie: push oraz pop.
Obszar stosu to ten fragment pamici programu, w ktrej procesor przechowuje swj stos.
Stos jest dynamiczn struktur danych, ktra zwiksza lub zmniejsza swj rozmiar w zalenoci
od biecych potrzeb programu. Stos zawiera te wane dla poprawnego dziaania programu
informacje, w tym zmienne lokalne (automatyczne), informacje o wywoaniach procedur i dane
tymczasowe.
W procesorach 80x86 pami stosu kontrolowana jest za porednictwem rejestru ESP zwanego te wskanikiem stosu. Kiedy program zaczyna dziaanie, system operacyjny inicjalizuje
wskanik stosu adresem ostatniej komrki pamici w obszarze pamici stosu (najwikszym
moliwym adresem w obszarze pamici stosu). Zapis danych do tego obszaru odbywa si jako
odkadanie danych na stos (ang. pushing) i zdejmowanie danych ze stosu (ang. popping).
3.8.1. Podstawowa posta instrukcji push

Oto skadnia instrukcji push procesora 80x86:
push( rejestr16 );
push( rejestr32 );
push( pami16 );
push( pami32 );
pushw( staa );
pushd( staa );
Zaprezentowanych wyej sze wersji instrukcji push pozwala na odkadanie na stos obiektw
typu word i dword, czyli zawartoci rejestrw 16- i 32-bitowych, jak rwnie wartoci przechowywanych w postaci sw i podwjnych sw w pamici. W szczeglnoci za nie jest moliwe
odkadanie na stos wartoci typu byte.
Dziaanie instrukcji push mona rozpisa nastpujcym pseudokodem:
ESP := ESP - rozmiar-operandu (2 bd 4)
[ESP] := warto-operandu
Operandami instrukcji pushw i pushd s zawsze stae o rozmiarze odpowiednio: sowa bd
podwjnego sowa.
1 64
Rozdzia 3.
Jeli na przykad rejestr ESP zawiera warto $00FF_FFE8, to wykonanie instrukcji

push( eax ); spowoduje ustawienie rejestru ESP na warto $00FF_FFE4 i skopiowanie bie-
cej wartoci rejestru EAX pod adres $00FF_FFE4; proces ten ilustruj rysunki 3.9 oraz 3.10.
Rysunek 3.9. Stan pamici stosu przed wykonaniem instrukcji push
Rysunek 3.10. Stan pamici stosu po wykonaniu instrukcji push

Wykonanie instrukcji push( eax ); nie wpywa przy tym w aden sposb na zawarto
rejestru EAX.
Cho procesory z rodziny 80x86 implementuj 16-bitowe wersje instrukcji manipulujcych pamici stosu, to owe wersje maj zastosowanie gwnie w rodowiskach 16-bitowych, jak
system DOS. Tymczasem gwoli maksymalnej wydajnoci warto, aby warto wskanika stosu
bya zawsze cakowit wielokrotnoci liczby cztery; program moe zreszt w systemie takim
jak Windows czy Linux zosta awaryjnie zatrzymany, kiedy system wykryje, e wskanik stosu
zawiera warto niepodzieln bez reszty przez cztery. Jedynym uzasadnieniem dla odkadania
na stosie danych innych ni 32-bitowe jest wic konstruowanie za porednictwem stosu wartoci
o rozmiarze podwjnego sowa skadanej z dwch sw umieszczonych na stosie jedno po drugim.
1 65
3.8.2. Podstawowa posta instrukcji pop

Do zdejmowania danych umieszczonych wczeniej na stosie suy instrukcja pop. W swej podstawowej wersji instrukcja ta przyjmuje jedn z czterech postaci:
pop(
pop(
pop(
pop(
rejestr16 );
rejestr32 );
pamie16 );
pami32 );
Podobnie jak to ma miejsce w przypadku instrukcji push, instrukcja pop obsuguje jedynie
operandy 16- i 32-bitowe; ze stosu nie mona zdejmowa wartoci omiobitowych. Podobnie
jednak jak przy instrukcji push, zdejmowania ze stosu wartoci 16-bitowych powinno si unika,
chyba e operacja taka stanowi jedn z dwch operacji zdejmowania ze stosu realizowanych pod
rzd) zdjcie ze stosu danej 16-bitowej powoduje, e warto rejestru wskanika stosu nie
dzieli si bez reszty przez cztery, co nie jest podane. W przypadku instrukcji pop dochodzi
jeszcze jedno ograniczenie: nie da si pobra wartoci ze stosu, okrelajc w instrukcji operand
w postaci staej jest to zreszt ograniczenie o tyle naturalne, e operand instrukcji push jest
operandem rdowym i jako taki moe by sta; trudno natomiast, aby sta by operand docelowy, a taki wystpuje w instrukcji pop.
Sposb dziaania instrukcji pop mona opisa nastpujcym pseudokodem:
operand := [ESP]
ESP := ESP + rozmiar-operandu (2 bd 4)
Operacja zdejmowania ze stosu jest, jak wida, operacj dokadnie odwrotn do operacji
odkadania danych na stosie. Instrukcja pop realizuje bowiem kopiowanie wartoci spod adresu
wskazywanego wskanikiem stosu jeszcze przed jego zwikszeniem. Obraz pamici stosu przed
i po wykonaniu instrukcji pop ilustruj rysunki 3.11 oraz 3.12.
Rysunek 3.11. Stan pamici stosu przed wykonaniem instrukcji pop
1 66
Rozdzia 3.
Rysunek 3.12. Stan pamici stosu po wykonaniu instrukcji pop

Naley podkreli, e warto zdjta ze stosu wci znajduje si w obszarze pamici stosu.
Zdejmowanie danej ze stosu nie oznacza zamazywania pamici stosu; efekt zniknicia danej
ze stosu osigany jest przez przesunicie wskanika stosu tak, aby wskazywa warto ssiadujc z wartoci zdjt (o wyszym adresie). Nigdy jednak nie naley prbowa odwoywa si
do danej zdjtej ju ze stosu nastpne odoenie czegokolwiek na stos powoduje ju bowiem
nadpisanie obszaru, w ktrym owa dana si wczeniej znajdowaa. A poniewa nie wolno zakada, e stos manipulowany jest wycznie kodem programu (stos jest wykorzystywany tak przez
system operacyjny, jak i kod wywoujcy procedury), nie powinno si inicjowa odwoa do
danych, ktre zostay ju zdjte ze stosu i co do ktrych istnieje jedynie podejrzenie (bo przecie nie pewno), e jeszcze s obecne w pamici stosu.
3.8.3. Zachowywanie wartoci rejestrw

za pomoc instrukcji push i pop
Najwaniejszym chyba zastosowaniem instrukcji pop i push jest zachowywanie zawartoci rejestrw w obliczu potrzeby ich czasowego innego ni dotychczasowe wykorzystania. W architekturze 80x86 gospodarka rejestrami jest o tyle problematyczna, e procesor ten zawiera wyjtkowo
ma liczb rejestrw oglnego przeznaczenia. Rejestry znakomicie nadaj si do przechowywania wartoci tymczasowych (np. wynikw porednich etapw oblicze ), ale s te potrzebne
do realizacji rnych trybw adresowania. Z tego wzgldu programista czsto staje w obliczu
niedostatku rejestrw, zwaszcza kiedy kod realizuje zoone obliczenia. Ratunkiem mog by
wtedy instrukcje push oraz pop.
Rozwamy nastpujcy zarys programu:
// sekwencja instrukcji wykorzystujcych rejestr EAX
// sekwencja instrukcji, na potrzeby ktrych naley zwolni rejestr EAX
// kontynuacja sekwencji instrukcji wykorzystujcych rejestr EAX
1 67
Do zaimplementowania takiego planu znakomicie nadaj si instrukcje push oraz pop. Za ich
pomoc mona najpierw zachowa, a nastpnie przywrci zawarto rejestru EAX; w midzyczasie mona za zrealizowa kod wymagajcy zwolnienia tego rejestru:
// sekwencja instrukcji wykorzystujcych rejestr EAX
push( eax );
// sekwencja instrukcji, na potrzeby ktrych naley zwolni rejestr EAX
pop( eax );
// kontynuacja sekwencji instrukcji wykorzystujcych rejestr EAX
Umiejtnie osadzajc w kodzie instrukcje push i pop, mona zachowa na stosie wynik oblicze realizowanych za porednictwem rejestru EAX na czas wykonania kodu, ktry ten rejestr
wykorzystuje w innym celu. Po zako czeniu owego fragmentu kodu mona przywrci poprzednio zachowan warto EAX i kontynuowa przerwane obliczenia.
3.9. Stos jako kolejka LIFO

Nie jest powiedziane, e stos naley wykorzystywa do odkadania wycznie pojedynczych
danych. Stos jest bowiem po prostu implementacj kolejki LIFO (ang. last in, first out, czyli
ostatnie na wejciu pierwsze na wyjciu). Obsuga takiej kolejki dla caych sekwencji danych
wymaga jednak uwanego kontrolowania kolejnoci odkadania i zdejmowania danych. Rozwamy
na przykad sytuacj, gdy na czas realizacji pewnych instrukcji naley zachowa zawarto
rejestrw EAX I EBX. Pocztkujcy programista mgby zrealizowa zabezpieczenie na stosie
wartoci rejestrw tak:
push( eax );
push( ebx );
// Sekwencja kodu wymagajca zwolnienia rejestrw EAX i EBX.
pop( eax );
pop( ebx );
Niestety, powyszy kod bdzie dziaa niepoprawnie! Bd zawarty w tym kodzie ilustruj
rysunki 3.13 do 3.16. Problem mona opisa nastpujco: na stos najpierw odkadany jest rejestr
EAX, a po nim EBX. Wskanik stosu wskazuje w efekcie adres pamici stosu, pod ktrym skadowana jest zawarto rejestru EBX. Kiedy w ramach przywracania poprzednich wartoci rejestrw wykonywana jest instrukcja pop( eax );, do rejestru EAX trafia warto, ktra pierwotnie
znajdowaa si w rejestrze EBX! Z kolei nastpna instrukcja, pop( ebx );, aduje do rejestru
EBX warto, ktra powinna tak naprawd trafi do rejestru EAX! Do zamiany wartoci rejestrw doszo w wyniku zastosowania niepoprawnej sekwencji zdejmowania ze stosu dane
powinny by z niego zdejmowane w kolejnoci odwrotnej, ni zostay na odoone.
Stos, jako struktura odpowiadajca kolejce LIFO, ma t waciwo, e to, co trafia na stos
jako pierwsze, powinno z niego zosta zdjte w ostatniej kolejnoci. Dla uproszczenia warto
zapamita nastpujc regu:
1 68
Rozdzia 3.
Rysunek 3.13. Obraz pamici stosu po odoeniu na niego zawartoci rejestru EAX
Rysunek 3.14. Obraz pamici stosu po odoeniu na niego zawartoci rejestru EBX
Rysunek 3.15. Obraz pamici stosu po zdjciu z niego danej do rejestru EAX
1 69
Rysunek 3.16. Obraz pamici stosu po zdjciu z niego danej do rejestru EBX
Dane ze stosu naley zdejmowa w kolejnoci odwrotnej do ich odkadania.
Problematyczny kod mona poprawi nastpujco:
push( eax );
push( ebx );
// Sekwencja kodu wymagajca zwolnienia rejestrw EAX i EBX.
pop( ebx );
pop( eax );
Jest jeszcze jedna wana regua, ktrej stosowanie pozwala unika bdw wynikajcych
z nieodpowiedniego manipulowania stosem:
Zdejmowa ze stosu naley dokadnie tyle bajtw, ile si wczeniej na odoyo.
Chodzi o to, aby liczba i ciar danych zdejmowanych ze stosu bya dokadnie rwna
liczbie i ciarowi danych na ten stos wczeniej odkadanych. Jeli liczba instrukcji pop jest
zbyt maa, na stosie pozostan osierocone dane, co moe w dalszym przebiegu programu
doprowadzi do bdw wykonania. Jeszcze gorsza jest sytuacja, kiedy liczba instrukcji pop
jest zbyt dua to niemal zawsze prowadzi do zaamania programu.
Szczegln wag naley przykada do zrwnowaenia operacji odkadania i zdejmowania realizowanych w ptli. Czstym bdem jest odkadanie danych na stos wewntrz
ptli i ich tylko jednokrotne zdejmowanie po wyjciu z ptli (bd odwrotnie) prowadzi
to oczywicie do naruszenia spjnoci danych na stosie. Naley wic pamita, e znaczenie
ma nie liczba instrukcji w kodzie rdowym programu, ale to, ile razy zostan one wykonane
w fazie wykonania. A w fazie tej liczba instrukcji pop musi odpowiada liczbie (i kolejnoci)
instrukcji push.
3.9.1. Pozostae wersje instrukcji obsugi stosu

Procesory z rodziny 80x86 udostpniaj programicie szereg dodatkowych wersji instrukcji
manipulujcych stosem. Wrd nich s nastpujce instrukcje maszynowe:
1 70
Rozdzia 3.
Q
Q
Q
Q
pusha
pushad
pushf
pushfd
Q
Q
Q
Q
popa
popad
popf
popfd
Wykonanie instrukcji pusha powoduje odoenie na stos wszystkich 16-bitowych rejestrw

oglnego przeznaczenia. Instrukcja ta wykorzystywana jest gwnie w 16-bitowych systemach
operacyjnych takich jak MS-DOS. W oglnoci wic potrzeba jej wykorzystania jest raczej
rzadka. Rejestry s na stosie odkadane w nastpujcej kolejnoci:
ax
cx
dx
bx
sp
bp
si
di
Instrukcja pushad powoduje odoenie na stosie wszystkich 32-bitowych rejestrw oglnego

przeznaczenia. Ich zawarto lduje na stosie w nastpujcej kolejnoci:
eax
ecx
edx
ebx
esp
ebp
esi
edi
Nie sposb nie zauway, e wykonanie instrukcji pusha (pushad) powoduje zmodyfikowanie
wartoci wskanika stosu SP (ESP). Powstaje wic pytanie, po co w ogle w rejestr jest odkadany na stosie? Prawdopodobnie odpowied na to pytanie wynika z tego, e ze wzgldw technicznych atwiejsze jest zapewne odoenie na stos wszystkich rejestrw naraz, bez czynienia
wyjtku dla nieaktualnego w chwili odkadania na stos rejestru SP (ESP).
Instrukcje popa i popad to odpowiadajce instrukcjom pusha i pushad instrukcje zdejmowania
ze stosu caych grup wartoci do rejestrw oglnego przeznaczenia. Naturalnie instrukcje te
zachowuj waciwy porzdek zdejmowania ze stosu zawartoci poszczeglnych rejestrw,
odwrotny do kolejnoci ich odkadania.
Mimo e stosowanie zbiorczych instrukcji pusha (pushad) oraz popa (popad) jest bardzo
wygodne, ich realizacja przebiega nieco duej, ni gdyby w ich miejsce zastosowa stosown
sekwencj instrukcji push i pop. Nie jest to specjalnym problemem, jako e rzadko zachodzi
1 71
potrzeba odkadania na stos zawartoci wikszej liczby rejestrw11. Jeli wic w programie chodzi
o maksymaln wydajno przetwarzania, naley kadorazowo przeanalizowa sensowno wykonania instrukcji zbiorczego odkadania rejestrw na stos.
Instrukcje pushf, pushfd, popf i popfd powoduj, odpowiednio: umieszczenie i zdjcie ze stosu
rejestru znacznikw EFLAGS. Instrukcje te pozwalaj na zachowanie sowa stanu programu
na czas wykonania pewnej sekwencji instrukcji. Niestety, trudniej jest zachowa wartoci pojedynczych znacznikw. Instrukcj pushf(d) i popf(d) mona zachowywa na stosie jedynie wszystkie znaczniki naraz; bardziej bolesne jest jednak to, e rejestr znacznikw rwnie przywrci
mona tylko w caoci.
Przy zachowywaniu i przywracaniu wartoci rejestru znacznikw naley korzysta
z 32-bitowej wersji instrukcji, czyli pushfd i popfd. Co prawda dodatkowe 16 bitw odoonych
na stosie nie jest w typowych aplikacjach nijak wykorzystywane, ale przynajmniej zachowuje si
w ten sposb wyrwnanie stosu, ktrego wskanik powinien by zawsze liczb podzieln bez
reszty przez cztery.
3.9.2. Usuwanie danych ze stosu bez ich zdejmowania

Okazjonalnie moe pojawi si kwestia nastpujca: na stos odoone zostay pewne dane, ktre
jednak ju dalej w programie nie bd wykorzystywane. Mona co prawda zdj te dane ze stosu
instrukcj pop, umieszczajc je w nieuywanym akurat rejestrze, ale mona to rwnie zrobi
metod prostsz, mianowicie ingerujc w warto rejestru wskanika stosu.
Niech ilustracj tego zagadnienia bdzie nastpujcy kod:
push( eax );
push( ebx );
// Kod ko czcy obliczenia na rejestrach EAX i EBX.
if( Calculation_was_performed ) then
// Hm Jest ju wynik i odoone na stos wartoci nie bd w takim razie potrzebne.
// Co z nimi zrobi?
else
// Konieczne dalsze obliczenia; przywr zawarto rejestrw.
pop( ebx );
pop( eax );
endif;
11
Na przykad bardzo rzadko zachodzi potrzeba odoenia na stos (albo zdjcia ze stosu) zawartoci
rejestru ESP w ramach sekwencji instrukcji pushad-popad.
1 72
Rozdzia 3.
W ramach klauzuli then instrukcji if naleaoby usun ze stosu poprzednie wartoci rejestrw EAX i EBX, ale bez wpywania na zawarto pozostaych rejestrw czy zmiennych. Jak to
zrobi?
Mona wykorzysta fakt, e rejestr ESP przechowuje wprost warto wskanika stosu, czyli
szczytowego elementu stosu; wystarczy wic dostosowa t warto tak, aby wskanik stosu wskazywa na niszy, kolejny element stosu. W prezentowanym przykadzie ze szczytu stosu naleao
usun dwie wartoci o rozmiarze podwjnego sowa. Efekt usunicia ich ze stosu mona osign, dodajc do wskanika stosu liczb osiem (takie usuwanie danych ze stosu ilustruj
rysunki 3.17 oraz 3.18):
push( eax );
push( ebx );
add( 8, ESP );
// Usu niepotrzebne dane ze stosu.
else
// Konieczne dalsze obliczenia; przywr zawarto rejestrw.
pop( ebx );
pop( eax );
endif;
Rysunek 3.17. Usuwanie danych ze stosu;

obraz pamici stosu przed wykonaniem instrukcji add( 8, ESP )
1 73
Rysunek 3.18. Usuwanie danych ze stosu;

obraz pamici stosu po wykonaniu instrukcji add( 8, ESP )
W ten sposb mona zdj dane ze stosu bez umieszczania ich w jakimkolwiek operandzie
docelowym. zwikszenie wskanika stosu jest te szybsze ni wykonanie sekwencji sztucznych instrukcji pop, poniewa w pojedynczej instrukcji add moemy zwikszy wskanik stosu
o wiksz liczb podwjnych sw.
Ostrzeenie
Przy usuwaniu danych ze stosu nie wolno zapomina o zachowaniu wyrwnania stosu. Rejestr
wskanika stosu ESP naley kadorazowo modyfikowa o liczb bdc cakowit wielokrotnoci liczby cztery.
3.10. Odwoywanie si do danych na stosie

bez ich zdejmowania
Czasami zdarza si, e do danych odoonych na stosie trzeba si odwoa, ale ich ze stosu nie
zdejmowa moe na przykad chodzi o czasowe przywrcenie odoonej wartoci i by moe
nawet jej modyfikowanie, z zachowaniem rezerwy pierwotnej wartoci na stosie, celem ich
pniejszego zdjcia. Ot mona to zrobi, korzystajc z adresowania postaci [ rejestr32 +
przesunicie ].
Rozwamy obraz pamici stosu (rysunek 3.19) po wykonaniu dwch poniszych instrukcji:
push( eax );
push( ebx );
Jeli zachodzi teraz potrzeba odwoania si do poprzedniej zawartoci rejestru EBX bez
zdejmowania go ze stosu, mona by sprbowa maego oszustwa: zdj dan ze stosu do rejestru EBX i natychmiast j z powrotem odoy na stos. Gorzej, kiedy bdzie trzeba odwoa si
1 74
Rozdzia 3.
Rysunek 3.19. Pami stosu po odoeniu na

zawartoci rejestrw EAX i EBX
do poprzedniej wartoci rejestru EAX albo innej wartoci, odoonej na stos jeszcze wczeniej.
Zdejmowanie ze stosu wszystkich zasaniajcych j danych (a nastpnie ich umieszczenie
z powrotem na stosie) byoby w najlepszym razie problematyczne, a w najgorszym niemoliwe do wykonania. Na rysunku 3.19 wida jednake, e kada z wartoci odoonych na stos
znajduje si w pamici obszaru stosu pod adresem odlegym od biecej wartoci wskanika
stosu o okrelon warto przesunicia, dlatego mona skorzysta z odwoania postaci [ ESP +
przesunicie ] i odwoa si do podanej wartoci bezporednio w pamici stosu. W powyszym przykadzie mona, na przykad, przywrci poprzedni zawarto rejestru EAX, wykonujc instrukcj:
mov( [esp + 4], eax );
Wykonanie tej instrukcji spowoduje skopiowanie do rejestru EAX wartoci znajdujcej si
pod adresem ESP+4. Adres ten okrela dan znajdujc si bezporednio pod szczytem stosu.
Technik t mona jednak z powodzeniem stosowa rwnie do danych znajdujcych si gbiej.
Ostrzeenie
Nie wolno zapomina, e przesunicia konkretnych elementw w pamici stosu zmieniaj si
w wyniku wykonania kadej instrukcji push i pop. Pominicie tego faktu moe doprowadzi do
stworzenia trudnego do modyfikowania kodu rdowego. Opieranie si na zaoeniu, e przesunicie jest stae pomidzy punktem w programie, w ktrym dane zostay na stos odoone, a punktem, w ktrym programista zdecydowa si do nich odwoa, moe uniemoliwia bd utrudnia
uzupenianie kodu, zwaszcza jeli uzupenienie bdzie zawiera instrukcje manipulujce stosem.
W poprzednim punkcie pokazany zosta sposb usuwania danych ze stosu polegajcy na
modyfikowaniu wartoci rejestru wskanika stosu. Prezentowany przy tej okazji kod mona by
jeszcze ulepszy, zapisujc go nastpujco:
1 75
push( eax );
push( ebx );
// Nadpisz wartoci przechowywane na stosie nowymi wartociami EAX i EBX, tak aby
// mona byo bezpiecznie zdj je ze stosu, nie ryzykujc utraty biecej zawartoci rejestrw.
mov( eax, [esp + 4] );
mov( ebx, [esp] );
endif;
pop( eax );
pop( ebx );
W powyszej sekwencji kodu wynik pewnych oblicze zosta zapisany w miejscu poprzednich wartoci rejestrw EAX i EBX. Kiedy pniej wykonane zostan instrukcje zdjcia ze
stosu, rejestry EAX i EBX pozostan niezmienione wci bd zawiera obliczone i uznane
w instrukcji if za ostateczne wartoci.
3.11. Dynamiczny przydzia pamici

obszar pamici sterty
Potrzeby pamiciowe co prostszych programw mog by skutecznie zaspokajane deklaracjami
zmiennych statycznych i automatycznych. Jednak bardziej zaawansowane zastosowania wymagaj moliwoci przydziau i zwalniania pamici w sposb dynamiczny, kiedy decyzje o potrzebie przydziau podejmowane s nie na etapie pisania kodu, a w fazie wykonania programu.
W jzyku C do dynamicznego przydzielania pamici suy funkcja malloc, a do jej zwalniania
funkcja free. Jzyk C++ przewiduje wykorzystanie do tych samych celw operatorw new oraz
delete. W Pascalu mamy funkcje new i dispose. Analogiczne mechanizmy dostpne s te
w innych jzykach programowania wysokiego poziomu. Wszystkie one dziel nastpujce cechy:
pozwalaj programicie na okrelenie rozmiaru przydzielanej pamici, zwracaj wskanik do
pocztku obszaru przydzielonej pamici i umoliwiaj zwrcenie pamici do systemu, kiedy
nie bdzie ju potrzebna. Jak mona si domyla, rwnie w jzyku HLA a konkretnie
w ramach biblioteki standardowej HLA dostpne s procedury realizujce przydzia i zwalnianie pamici.
Przydzia pamici jest w jzyku HLA realizowany za porednictwem procedury bibliotecznej mem.alloc, jej zwalnianie odbywa si za za porednictwem procedury mem.free. Procedura mem.alloc wywoywana jest nastpujco:
mem.alloc( liczba-bajtw );
1 76
Rozdzia 3.
Jedyny argument wywoania procedury mem.alloc to warto o rozmiarze podwjnego sowa,

okrelajca liczb bajtw, jaka ma zosta przydzielona do programu. Stosownej wielkoci pami
przydzielana jest w obszarze pamici sterty. Wywoanie funkcji powoduje przydzielenie wolnego bloku tej pamici i oznaczenie tego bloku jako zajtego, co pozwala na ochron pamici
przed wielokrotnym przydziaem. Po oznaczeniu bloku pamici jako zajtego procedura
zwraca za porednictwem rejestru EAX wskanik na pierwszy bajt przydzielonego obszaru.
W przypadku wikszoci obiektw liczba bajtw niezbdna do prawidowego zachowania
obiektu w pamici jest programicie znana. Na przykad chcc dynamicznie przydzieli pami
dla zmiennej typu uns32, mona skorzysta z nastpujcego wywoania:
mem.alloc( 4 );
Jak wida, w wywoaniu procedury mem.alloc mona skutecznie umieszcza literay liczbowe,
ale w oglnym przypadku lepiej jest skorzysta z dostpnej w HLA funkcji czasu kompilacji12
o nazwie @size. Wywoanie tej funkcji jest zastpowane obliczonym przez kompilator rozmiarem
danych. Skadnia wywoania @size jest nastpujca:
@size( nazwa-zmiennej-bd-typu )
Wywoanie funkcji @size zastpowane jest sta liczb cakowit rwn rozmiarowi parametru
wywoania, okrelonemu w bajtach. Poprzednie wywoanie procedury przydziau mem.alloc
mona wic zapisa nastpujco:
mem.alloc( @size( uns32 ) );
Powysze wywoanie spowoduje przydzielenie w obszarze pamici sterty obszaru odpowiedniego do przechowywania obiektu zadanego typu. Co prawda nie naley si spodziewa,
aby rozmiar typu danych uns32 zosta kiedykolwiek zmieniony, jednak w przypadku innych
typw danych (zwaszcza tych definiowanych przez uytkownika) stao rozmiaru nie jest ju
taka pewna, wic warto wyrobi sobie nawyk stosowania w miejsce literaw liczbowych wywoania funkcji @size.
Po zako czeniu wykonywania kodu procedury mem.alloc w rejestrze EAX powinien znajdowa si wskanik na przydzielony obszar pamici patrz rysunek 3.20.
Aby odwoa si do pamici przydzielonej w wyniku wywoania procedury mem.alloc, naley
skorzysta z adresowania poredniego przez rejestr. Oto przykad przypisania wartoci 1234
do zmiennej typu uns32 przydzielonej w pamici sterty:
mov( 1234, (type uns32 [eax] ) );
12
Funkcja czasu kompilacji to taka, ktrej warto jest obliczana nie w czasie wykonania programu, a ju
na etapie kompilacji.
1 77
Rysunek 3.20. Wywoanie procedury mem.alloc

zwraca w rejestrze EAX wska nik na przydzielony obszar
Warto zwrci uwag na zastosowanie w powyszym kodzie operatora koercji typu rejestru.
Ot jest on tu niezbdny, poniewa zmienne anonimowe nie maj adnego typu, wic kompilator nie mgby stwierdzi zgodnoci rozmiarw operandw w ko cu warto 1234 da si
te zapisa zarwno w zmiennej o rozmiarze sowa, jak i w zmiennej o rozmiarze podwjnego
sowa. Zastosowanie operatora koercji typu pozwala na rozstrzygnicie niejednoznacznoci.
Przydzia pamici za porednictwem procedury mem.alloc nie zawsze jest skuteczny. Jeli na
przykad w obszarze pamici sterty nie istnieje odpowiednio duy cigy obszar wolnej pamici,
wywoanie mem.alloc sprowokuje wyjtek ex.MemoryAllocationFailure. Jeli wywoanie nie
zostanie osadzone w bloku kodu chronionego instrukcji try, bd przydziau pamici spowoduje awaryjne zatrzymanie wykonania programu. Jako e wikszo programw nie przydziela
jakich gigantycznych obszarw pamici, wyjtek ten zgaszany jest stosunkowo rzadko. Niemniej jednak nie powinno si zakada, e przydzia pamici bdzie zawsze skuteczny.
Kiedy operacje na obiektach danych przydzielonych w pamici sterty zostan zako czone,
mona zajmowan przez te obiekty pami zwolni do systemu operacyjnego, czyli oznaczy
jako woln. Suy do tego procedura mem.free. Procedura ta przyjmuje pojedynczy argument,
ktrym musi by adres zwrcony podczas odpowiedniego wywoania przydzielajcego pami.
Dodatkowo nie moe to by adres pamici raz ju zwolnionej. Sposb wykorzystywania pary
instrukcji mem.alloc i mem.free ilustruje nastpujcy przykad:
// Manipulowanie obiektami w pamici o adresie zwrconym przez rejestr EAX.
// Uwaga: ten kod nie moe modyfikowa zawartoci EAX.
mem.free( eax );
Niniejszy kod ilustruje bardzo wan zaleno aby skutecznie zwolni pami przydzielon wywoaniem mem.alloc, naley zachowa wskanik zwracany przez to wywoanie. Jeli
1 78
Rozdzia 3.
rejestr EAX jest na czas wykorzystywania pamici dynamicznej potrzebny do innych celw,
mona w wskanik zachowa na stosie albo po prostu skopiowa go do zmiennej w pamici.
Zwolnione obszary pamici s dostpne dla nastpnych operacji przydziau, realizowanych
za porednictwem procedury mem.alloc. Moliwo przydzielania pamici do obiektw i jej
zwalniania w razie potrzeby znakomicie zwiksza efektywno wykorzystania pamici. Zwalniajc niepotrzebn ju pami dynamiczn, mona j udostpni dla innych celw, zmniejszajc zajto pamici w porwnaniu z sytuacj, w ktrej pami dla takich tymczasowych danych
przydzielana bya statycznie.
Z wykorzystaniem wskanikw wie si kilka problemw. Czsto powoduj one u niedowiadczonych programistw nastpujce bdy nieprawidowej obsugi pamici dynamicznej:
Q Odwoywanie si do zwolnionych wczeniej obszarw pamici. Po zwrceniu pamici
do systemu (wywoaniem procedury mem.free) nie mona ju odwoywa si do tej
pamici. Odwoania takie mog doprowadzi do sprowokowania bdu ochrony pamici
albo co gorsze, bo trudniejsze do wykrycia nadpisanie innych danych przydzielanych
pniej dynamicznie w zwolnionym obszarze pamici.
Q Dwukrotne wywoywanie procedury mem.free w odniesieniu do tego samego obszaru
pamici. Powtrne wywoanie procedury mem.free moe doprowadzi do nieumylnego
zwolnienia innego obszaru pamici albo wrcz naruszy spjno tablic podsystemu
zarzdzania pamici.
W rozdziale 4. omwionych zostanie jeszcze kilka innych problemw zwizanych z obsug
pamici dynamicznej.
Wszystkie prezentowane dotychczas przykady pokazyway przydzia i zwalnianie pamici dla
pojedynczych zmiennych okrelonego typu 32-bitowej zmiennej bez znaku. Tymczasem naturalnie przydzia moe dotyczy dowolnego typu danych, okrelonego w wywoaniu procedury
mem.alloc nazw typu albo po prostu liczb potrzebnych bajtw. Mona w ten sposb przydziela pami dla caych sekwencji obiektw. Na przykad ponisze wywoanie realizuje przydzia
pamici dla omiu znakw:
mem.alloc( @size( char ) * 8 );
W powyszej instrukcji uwag zwraca zastosowanie wyraenia staowartociowego w celu

obliczenia liczby bajtw wymaganych do przechowywania omioznakowej sekwencji. Jako e
funkcja @size(char) zwraca zawsze rozmiar (w bajtach) pojedynczego znaku, to przydzia pamici
dla omiu znakw naley zasygnalizowa osiem razy wikszym argumentem wywoania; wyraenie staowartociowe, nawet najbardziej zoone, jest obliczane przez kompilator i nie powoduje wstawienia do kodu maszynowego adnych dodatkowych instrukcji.
Wywoanie procedury mem.alloc dla liczby bajtw wikszej ni jeden powoduje zawsze
przydzia cigego obszaru pamici o zadanym rozmiarze. Std dla prezentowanego wczeniej
wywoania w pamici sterty zarezerwowana zostanie omiobajtowa porcja pamici, jak zostao
to pokazane na rysunku 3.21.
1 79
Rysunek 3.21. Przydzia pamici dla sekwencji znakw

Do kolejnych znakw sekwencji mona si odwoywa, okrelajc ich przesunicie wzgldem
adresu bazowego sekwencji zwracanego przez rejestr EAX. Na przykadu, aby zapisa w trzecim znaku sekwencji warto przechowywan w rejestrze CH, naley skorzysta z instrukcji
mov( CH, [eax + 2] );. Mona te, na przykad, skorzysta z adresowania [eax + ebx] i wtedy
przesunicie odwoania okrela zawartoci rejestru EBX, odpowiednio manipulujc jego wartoci. Na przykad poniszy kod ustawia wszystkie znaki 128-znakowej sekwencji na warto
NUL (warto #0):
mem.alloc( 128 );
for( mov( 0, ebx ); ebx < 128; add( 1, ebx ) ) do
mov( 0, ( type byte [eax + ebx] ) );
endfor;
W rozdziale 4., gdzie bd omawiane zoone struktury danych (w tym tablice elementw),
zaprezentowane zostan jeszcze inne sposoby odwoywania si do obszarw pamici zawierajcych sekwencje obiektw.
Naley jeszcze podkreli, e wywoanie procedury mem.alloc powoduje kadorazowo przydzielenie obszaru nieco wikszego ni dany. Bloki pamici dynamicznej maj pewne okrelone rozmiary minimalne (czsto s to rozmiary rwne kolejnym potgom dwjki w zakresie
od 2 do 16; jest to zalene wycznie od architektury systemu operacyjnego). Dalej, wykonanie
przydziau wymaga rwnie zarezerwowania kilku dodatkowych bajtw pomocniczych (jest
ich zwykle od 8 do 16), aby moliwe byo utrzymywanie informacji o blokach zajtych i wolnych. Niekiedy w narzut pamiciowy jest wikszy od danego rozmiaru przydziau, dlatego
procedura mem.alloc wywoywana jest raczej celem przydziau pamici dla duych obiektw,
jak tablice i zoone struktury danych jej wykorzystywanie do przydziau pojedynczych bajtw jest nieefektywne.
1 80
Rozdzia 3.
3.12. Instrukcje inc oraz dec

Przykad z poprzedniego podrozdziau uwidacznia, e jedn z czstszych operacji w jzyku
asemblerowym jest zwikszanie bd zmniejszanie o jeden wartoci jakiego rejestru czy zmiennej w pamici. Czstotliwo wystpowania tej operacji cakowicie usprawiedliwia obecno
w zestawie instrukcji maszynowych procesorw 80x86 pary instrukcji, ktre tak operacj implementuj: inc (dla zwikszenia o jeden) oraz dec (dla zmniejszenia o jeden).
Instrukcje te maj nastpujc skadni:
inc( rej/pam );
dec( rej/pam );
Operandem instrukcji moe by dowolny rejestr 8-bitowy, 16-bitowy bd 32-bitowy albo
dowolny operand pamiciowy. Instrukcja inc powoduje zwikszenie wartoci operandu o jeden;
instrukcja dec zmniejsza warto operandu o jeden.
Niniejsze instrukcje s realizowane nieco szybciej ni odpowiadajce im instrukcje add czy
sub (instrukcje te s kodowane na mniejszej liczbie bajtw). Ich zapis w kodzie maszynowym
rwnie jest bardziej oszczdny (w ko cu wystpuje tu tylko jeden operand). Ale to nie koniec
rnic pomidzy par inc-dec a par add-sub manipulowanie wartoci operandu za porednictwem instrukcji inc i dec nie wpywa bowiem na warto znacznika przeniesienia.
Przykadem zastosowania instrukcji inc moe by przykad ptli wykorzystany w poprzednim podrozdziale:
mem.alloc( 128 );
for( mov( 0, ebx ); ebx < 128; inc( ebx ) ) do
mov( 0, ( type byte [eax + ebx] ) );
endfor;
3.13. Pobieranie adresu obiektu

W podpunkcie 3.1.2.2 omawiane byo zastosowanie operatora pobrania adresu (&), ktry zwraca
adres zmiennej statycznej13. Niestety, operatora tego nie mona stosowa w odniesieniu do
zmiennych automatycznych (deklarowanych w sekcji var) ani zmiennych anonimowych; operator ten nie nadaje si te do pobrania adresu odwoania do pamici realizowanego w trybie
indeksowym albo indeksowym skalowanym (nawet jeli czci wyraenia adresowego jest
zmienna statyczna). Operator pobrania adresu (&) nadaje si wic wycznie do okrelania adresw prostych obiektw statycznych. Tymczasem niejednokrotnie zachodzi potrzeba okrelenia
13
Zmienna statyczna to zmienna deklarowana w kodzie rdowym programu, dla ktrej przydzia
pamici odbywa si na etapie kompilacji czy konsolidacji, czyli zmienna deklarowana w sekcjach
static, readonly i storage.
1 81
adresu rwnie obiektw innych kategorii. Na szczcie w zestawie instrukcji procesorw

z rodziny 80x86 przewidziana jest instrukcja zaadowania adresu efektywnego lea (od load
effective adres).
Skadnia instrukcji lea prezentuje si nastpujco:
lea( rejestr32, operand-pamiciowy );
Pierwszym z operandw musi by 32-bitowy rejestr. Operand drugi moe by dowolnym
dozwolonym odwoaniem do pamici przy uyciu dowolnego z dostpnych trybw adresowania. Wykonanie instrukcji powoduje zaadowanie okrelonego rejestru obliczonym adresem
efektywnym. Instrukcja nie wpywa przy tym w aden sposb na warto operandu znajdujcego
si pod obliczonym adresem.
Po zaadowaniu adresu efektywnego do 32-bitowego rejestru oglnego przeznaczenia mona
wykorzysta adresowanie porednie przez rejestr, adresowanie indeksowe, indeksowe skalowane,
celem odwoania si do obiektu okupujcego okrelony adres. Spjrzmy na nastpujcy przykad:
static
b:
byte; @nostorage;
byte 7, 0, 6, 1, 5, 2, 4, 3;
lea( ebx, b );
for( mov( 0, ecx ); ecx < 8; inc( ecx ) ) do
stdout.put( "[ebx+ecx]=", (type byte [ebx + ecx]), nl );
endfor;
Powyszy kod inicjuje ptl, w ramach ktrej nastpuje wywietlenie wartoci wszystkich
kolejnych bajtw nieetykietowanych, poczwszy od bajta znajdujcego si pod adresem zmiennej b. W odwoaniach zastosowany zosta tryb adresowania [ebx + ecx]. Rejestr EBX przechowuje tu adres bazowy sekwencji bajtw (adres pierwszego z bajtw sekwencji), a rejestr
ECX definiuje przesunicie adresu efektywnego, stanowic indeks sekwencji.
3.14. rda informacji dodatkowych

Pod adresem http://webster.cs.ucr.edu/ dostpne jest starsze wydanie niniejszej ksiki, pisane pod
ktem procesorw 16-bitowych. Mona tam znale informacje o 16-bitowych trybach adresowania procesorw 80x86 i o segmentacji pamici. Wicej informacji o funkcjach mem.alloc
i mem.free z biblioteki standardowej mona znale w podrczniku HLA Standard Library
Manual, rwnie dostpnym w witrynie Webster pod adresem http://webster.cs.ucr.edu/, ewentualnie na stronie WWW pod adresem http://artofasm.com/. Oczywicie, znakomitym rdem
informacji na ten temat jest dokumentacja procesorw x86 firmy Intel (do poszukania w witrynie
http://www.intel.com/), gdzie znajduje si komplet informacji o trybach adresowania i o kodowaniu instrukcji maszynowych.
1 82
Rozdzia 3.

Asembler. Sztuka Programowania. Wydanie II

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Asembler. Sztuka Programowania. Wydanie II

Uploaded by

Copyright:

Available Formats

Id do

Poznaj asembler od podstaw i zbuduj fundament swojej wiedzy o programowaniu

DO JZYKA ASEMBLEROWEGO .................................................... 17

Jeszcze o ochronie wykonania kodu w bloku try..endtry ......................................... 62

Organizacja pamici fazy wykonania .......................................................................144

Zoone typy danych .............................................................................................. 214

Funkcje i wartoci funkcji ........................................................................................314

Idiomy maszynowe a idiomy arytmetyczne ............................................................ 427

I OBIEKTY .................................................................................. 729

LEKTURY DWCH POPRZEDNICH ROZDZIA W

CZYTELNIK POZNA SPOSB

DEKLAROWANIA I ODWO YWANIA SI DO ZMIENNYCH W PROGRAMACH

W ROZDZIALE BIECYM POZNA PE NY OBRAZ

Q stosem procesora 80x86,

3.1. Tryby adresowania procesorw 80x86

3.1.1. Adresowanie przez rejestr

Powysza instrukcja kopiuje warto operandu rdowego do operandu docelowego.

// Kopiowanie zawartoci rejestru BX do rejestru AX

Rejestry s wymarzonym miejscem do przechowywania zmiennych. Instrukcje odwoujce

3.1.2. 32-bitowe tryby adresowania procesora 80x86

3.1.2.1. Adresowanie bezporednie

Dostp do pamici i jej organizacja

Rysunek 3.1. Tryb adresowania bezporedniego

Rysunek 3.2. Odwoanie do sowa i podwjnego sowa w trybie adresowania bezporedniego

3.1.2.2. Adresowanie porednie przez rejestr

// Zaadowanie rejestru EBX adresem zmiennej J.

Dostp do pamici i jej organizacja

3.1.2.3. Adresowanie indeksowe

gdzie zmienna jest nazw zmiennej programu.

Rysunek 3.3. Adresowanie indeksowe

3.1.2.4. Warianty trybu adresowania indeksowego

Rysunek 3.4. Adresowanie indeksowe: warto rejestru plus staa

Rysunek 3.5. Adresowanie indeksowe: warto rejestru minus staa

Dostp do pamici i jej organizacja

mov( zmienna[ ebx + staa ], al );

redukowana jest do nastpujcej instrukcji:

Obie stae s sumowane na etapie kompilacji, co ostatecznie daje nastpujc instrukcj

3.1.2.5. Adresowanie indeksowe skalowane

W powyszych przykadach rejestr-bazowy32 reprezentuje dowolny z 32-bitowych rejestrw

Rysunek 3.6. Adresowanie indeksowe skalowane

Dostp do pamici i jej organizacja

spowoduje skopiowanie do rejestru AL pojedynczego bajta spod adresu $2184 ($2000+

3.1.2.6. Adresowanie w piguce

3.2. Organizacja pamici fazy wykonania

Rysunek 3.7. Typowe rozmieszczenie elementw programu HLA w pamici

Najnisze adresy przestrzeni adresowej programu rezerwowane s przez system operacyjny.

3.2.1. Obszar kodu

Dostp do pamici i jej organizacja

A oto kilka konkretnych przykadw deklarowania danych nieetykietowanych w obszarze kodu:

to w ramach programu nastpi po wykonaniu pierwszej instrukcji mov prba wykonania

3.2.2. Obszar zmiennych statycznych

Dane osadzane w obszarze zmiennych statycznych za porednictwem pseudoinstrukcji s

3.2.3. Obszar niemodyfikowalny

Dostp do pamici i jej organizacja

Q dane obszaru niemodyfikowalnego zapowiadane s w kodzie rdowym sowem

Wszystkie deklaracje w sekcji readonly musz by uzupenione o wyraenie inicjalizacji

3.2.4. Obszar danych niezainicjalizowanych

Z jednym wyjtkiem opisanym w rozdziale 5.

3.2.5. Atrybut @nostorage

W powyszym przykadzie zmienna abcd to podwjne sowo, ktrego najmniej znaczcy

Dostp do pamici i jej organizacja

3.2.6. Sekcja deklaracji var

3.2.7. Rozmieszczenie sekcji deklaracji danych

Zoone typy danych .............................................................................................. 214

LEKTURY DWCH POPRZEDNICH ROZDZIAW

DEKLAROWANIA I ODWOYWANIA SI DO ZMIENNYCH W PROGRAMACH

W ROZDZIALE BIECYM POZNA PENY OBRAZ

Powysza instrukcja kopiuje warto operandu rdowego do operandu docelowego.

3.1.2.1. Adresowanie bezporednie

Rysunek 3.1. Tryb adresowania bezporedniego

Rysunek 3.2. Odwoanie do sowa i podwjnego sowa w trybie adresowania bezporedniego

3.1.2.2. Adresowanie porednie przez rejestr

// Zaadowanie rejestru EBX adresem zmiennej J.

Rysunek 3.4. Adresowanie indeksowe: warto rejestru plus staa

Rysunek 3.5. Adresowanie indeksowe: warto rejestru minus staa

redukowana jest do nastpujcej instrukcji:

Obie stae s sumowane na etapie kompilacji, co ostatecznie daje nastpujc instrukcj

3.1.2.6. Adresowanie w piguce

Dane osadzane w obszarze zmiennych statycznych za porednictwem pseudoinstrukcji s

Q dane obszaru niemodyfikowalnego zapowiadane s w kodzie rdowym sowem

Wszystkie deklaracje w sekcji readonly musz by uzupenione o wyraenie inicjalizacji

Powyszy przykad, oprcz moliwoci dowolnego porzdkowania poszczeglnych sekcji

3.5. Wyraenia adresowe

Rysunek 3.8. Wyraenie adresowe w odwoaniu do danej umieszczonej za zmienn

Kolejnym wanym spostrzeeniem jest to, e przesunicie w wyraeniu adres[przesunicie]

nakada na wszystkie skadowe wyraenia staowartociowego wymg okrelonoci wartoci

Uruchomienie programu z listingu 3.1 spowoduje wyprowadzenie na wyjcie wartoci 0,

W ko cu niezgodno rozmiarw operandw jest najczciej efektem nieuwagi programisty.

Powysza instrukcja nakazuje zaadowanie rejestru AX wartoci sowa rozpoczynajcego

W niektrych innych jzykach identyczny proces nosi nazw rzutowania.

Sabo t mona wyeliminowa, stosujc w wyraeniu logicznym instrukcji if koercj typu

zachodzi wic konieczno dokonania koercji typu rejestru.

3.8. Pami obszaru stosu

3.8.1. Podstawowa posta instrukcji push

Jeli na przykad rejestr ESP zawiera warto $00FF_FFE8, to wykonanie instrukcji

3.8.2. Podstawowa posta instrukcji pop

3.8.3. Zachowywanie wartoci rejestrw

3.9.1. Pozostae wersje instrukcji obsugi stosu

Rysunek 3.19. Pami stosu po odoeniu na

Jedyny argument wywoania procedury mem.alloc to warto o rozmiarze podwjnego sowa,

W powyszej instrukcji uwag zwraca zastosowanie wyraenia staowartociowego w celu

adresu rwnie obiektw innych kategorii. Na szczcie w zestawie instrukcji procesorw

3.14. rda informacji dodatkowych