Randall Hyde - Asembler sztuka programowania, Informatyka

[ Pobierz całość w formacie PDF ]
Spis treci
Rozdział 1. Wstp do jzyka asemblerowego......................................................13
1.1. Wprowadzenie ........................................................................................................ 13
1.2. Anatomia programu HLA....................................................................................... 13
1.3. Uruchamianie pierwszego programu HLA ............................................................. 16
1.4. Podstawowe deklaracje danych programu HLA..................................................... 17
1.5. Warto%ci logiczne ................................................................................................... 19
1.6. Warto%ci znakowe................................................................................................... 20
1.7. Rodzina procesorów 80x86 firmy Intel.................................................................. 21
1.7.1. Podsystem obsługi pami0ci........................................................................... 24
1.8. Podstawowe instrukcje maszynowe........................................................................ 26
1.9. Podstawowe struktury steruj1ce wykonaniem programu HLA............................... 30
1.9.1. Wyra2enia logiczne w instrukcjach HLA ..................................................... 31
1.9.2. Instrukcje if..then..elseif..else..endif j0zyka HLA ......................................... 33
1.9.3. Iloczyn, suma i negacja w wyra2eniach logicznych...................................... 35
1.9.4. Instrukcja while ............................................................................................ 37
1.9.5. Instrukcja for................................................................................................. 38
1.9.6. Instrukcja repeat............................................................................................ 39
1.9.7. Instrukcje break oraz breakif......................................................................... 40
1.9.8. Instrukcja forever.......................................................................................... 40
1.9.9. Instrukcje try, exception oraz endtry............................................................. 41
1.10. Biblioteka standardowa j0zyka HLA — wprowadzenie ......................................... 44
1.10.1. Stałe predefiniowane w module stdio ........................................................... 46
1.10.2. Standardowe wej%cie i wyj%cie programu ..................................................... 46
1.10.3. Procedura stdout.newln................................................................................. 47
1.10.4. Procedury stdout.putiN ................................................................................. 47
1.10.5. Procedury stdout.putiNSize .......................................................................... 48
1.10.6. Procedura stdout.put ..................................................................................... 49
1.10.7. Procedura stdin.getc...................................................................................... 51
1.10.8. Procedury stdin.getiN ................................................................................... 52
1.10.9. Procedury stdin.readLn i stdin.flushInput..................................................... 53
1.10.10. Procedura stdin.get ....................................................................................... 54
1.11. Jeszcze o ochronie wykonania kodu w bloku try..endtry........................................ 55
1.11.1. Zagnie2d2one bloki try..endtry ..................................................................... 56
1.11.2. Klauzula unprotected bloku try..endtry......................................................... 58
1.11.3. Klauzula anyexception bloku try..endtry ...................................................... 61
1.11.4. Instrukcja try..endtry i rejestry...................................................................... 61
1.12. J0zyk asemblerowy a j0zyk HLA ........................................................................... 63
1.13. <ródła informacji dodatkowych.............................................................................. 64
4
Asembler. Sztuka programowania
Rozdział 2. Reprezentacja danych......................................................................65
2.1. Wprowadzenie ........................................................................................................ 65
2.2. Systemy liczbowe ................................................................................................... 66
2.2.1. System dziesi0tny — przypomnienie............................................................ 66
2.2.2. System dwójkowy......................................................................................... 66
2.2.3. Formaty liczb dwójkowych........................................................................... 68
2.3. System szesnastkowy.............................................................................................. 69
2.4. Organizacja danych ................................................................................................ 72
2.4.1. Bity ............................................................................................................... 72
2.4.2. Półbajty......................................................................................................... 73
2.4.3. Bajty ............................................................................................................. 73
2.4.4. Słowa ............................................................................................................ 75
2.4.5. Podwójne słowa ............................................................................................ 76
2.4.6. Słowa poczwórne i długie............................................................................. 77
2.5. Operacje arytmetyczne na liczbach dwójkowych i szesnastkowych....................... 77
2.6. Jeszcze o liczbach i ich reprezentacji...................................................................... 78
2.7. Operacje logiczne na bitach.................................................................................... 81
2.8. Operacje logiczne na liczbach dwójkowych i ci1gach bitów.................................. 84
2.9. Liczby ze znakiem i bez znaku ............................................................................... 86
2.10. Rozszerzanie znakiem, rozszerzanie zerem, skracanie, przycinanie....................... 91
2.11. Przesuni0cia i obroty .............................................................................................. 95
2.12. Pola bitowe i dane spakowane ................................................................................ 99
2.13. Wprowadzenie do arytmetyki zmiennoprzecinkowej ........................................... 104
2.13.1. Formaty zmiennoprzecinkowe przyj0te przez IEEE ................................... 108
2.13.2. Obsługa liczb zmiennoprzecinkowych w j0zyku HLA ............................... 112
2.14. Reprezentacja liczb BCD ..................................................................................... 115
2.15. Znaki .................................................................................................................... 117
2.15.1. Zestaw znaków ASCII................................................................................ 117
2.15.2. Obsługa znaków ASCII w j0zyku HLA...................................................... 121
2.16. Zestaw znaków Unicode....................................................................................... 125
2.17. <ródła informacji dodatkowych............................................................................ 126
Rozdział 3. Dostp do pamici i jej organizacja ................................................127
3.1. Wprowadzenie ...................................................................................................... 127
3.2. Tryby adresowania procesorów 80x86 ................................................................. 127
3.2.1. Adresowanie przez rejestr........................................................................... 128
3.2.2. 32-bitowe tryby adresowania procesora 80x86........................................... 129
3.3. Organizacja pami0ci fazy wykonania ................................................................... 135
3.3.1. Obszar kodu................................................................................................ 137
3.3.2. Obszar zmiennych statycznych................................................................... 139
3.3.3. Obszar niemodyfikowalny .......................................................................... 140
3.3.4. Obszar danych niezainicjalizowanych ........................................................ 141
3.3.5. Atrybut @nostorage.................................................................................... 141
3.3.6. Sekcja deklaracji var ................................................................................... 142
3.3.7. Rozmieszczenie sekcji deklaracji danych w programie HLA ..................... 143
3.4. Przydział pami0ci dla zmiennych w programach HLA......................................... 144
3.5. Wyrównanie danych w programach HLA ............................................................ 146
3.6. Wyra2enia adresowe............................................................................................. 149
3.7. Koercja typów ...................................................................................................... 151
3.8. Koercja typu rejestru ............................................................................................ 154
3.9. Pami0E obszaru stosu oraz instrukcje push i pop .................................................. 155
3.9.1. Podstawowa postaE instrukcji push............................................................. 155
3.9.2. Podstawowa postaE instrukcji pop .............................................................. 157
3.9.3. Zachowywanie warto%ci rejestrów za pomoc1 instrukcji push i pop .......... 158
Spis treci
5
3.9.4. Stos jako kolejka LIFO ............................................................................... 159
3.9.5. Pozostałe wersje instrukcji obsługi stosu.................................................... 161
3.9.6. Usuwanie danych ze stosu bez ich zdejmowania ........................................ 163
3.9.7. Odwoływanie si0 do danych na stosie bez ich zdejmowania ...................... 165
3.10. Dynamiczny przydział pami0ci — obszar pami0ci sterty ..................................... 166
3.11. Instrukcje inc oraz dec.......................................................................................... 171
3.12. Pobieranie adresu obiektu..................................................................................... 171
3.13. <ródła informacji dodatkowych............................................................................ 172
Rozdział 4. Stałe, zmienne i typy danych..........................................................173
4.1. Wprowadzenie ...................................................................................................... 173
4.2. Kilka dodatkowych instrukcji: intmul, bound i into ............................................. 174
4.3. Typ tbyte............................................................................................................... 178
4.4. Deklaracje stałych i zmiennych w j0zyku HLA.................................................... 178
4.4.1. Typy stałych ............................................................................................... 182
4.4.2. Literały stałych łaGcuchowych i znakowych............................................... 183
4.4.3. Stałe łaGcuchowe i napisowe w sekcji const ............................................... 185
4.4.4. Wyra2enia stałowarto%ciowe....................................................................... 186
4.4.5. Wielokrotne sekcje const i ich kolejno%E w programach HLA ................... 189
4.4.6. Sekcja val programu HLA .......................................................................... 190
4.4.7. Modyfikowanie obiektów sekcji val w wybranym miejscu
kodu Iródłowego programu ....................................................................... 191
4.5. Sekcja type programu HLA .................................................................................. 192
4.6. Typy wyliczeniowe w j0zyku HLA ...................................................................... 193
4.7. Typy wskaInikowe ............................................................................................... 194
4.7.1. WskaIniki w j0zyku asemblerowym........................................................... 196
4.7.2. Deklarowanie wskaIników w programach HLA ........................................ 197
4.7.3. Stałe wskaInikowe i wyra2enia stałych wskaInikowych............................ 197
4.7.4. Zmienne wskaInikowe a dynamiczny przydział pami0ci ........................... 199
4.7.5. Typowe bł0dy stosowania wskaIników ...................................................... 200
4.8. Moduł chars.hhf biblioteki standardowej HLA .................................................... 205
4.9. Zło2one typy danych ............................................................................................ 207
4.10. ŁaGcuchy znaków ................................................................................................. 208
4.11. ŁaGcuchy w j0zyku HLA...................................................................................... 210
4.12. Odwołania do poszczególnych znaków łaGcucha ................................................. 217
4.13. Moduł strings biblioteki standardowej HLA i procedury manipulacji łaGcuchami ...219
4.14. Konwersje wewn1trzpami0ciowe ......................................................................... 231
4.15. Zbiory znaków...................................................................................................... 232
4.16. Implementacja zbiorów znaków w j0zyku HLA................................................... 233
4.17. Literały, stałe i wyra2enia zbiorów znaków w j0zyku HLA ................................. 235
4.18. Operator in w wyra2eniach logicznych
wysokopoziomowego rozszerzenia j0zyka HLA.................................................. 237
4.19. Obsługa zbiorów znaków w bibliotece standardowej HLA .................................. 237
4.20. Wykorzystywanie zbiorów znaków w programach HLA ..................................... 241
4.21. Tablice.................................................................................................................. 243
4.22. Deklarowanie tablic w programach HLA ............................................................. 244
4.23. Literały tablicowe ................................................................................................. 245
4.24. Odwołania do elementów tablicy jednowymiarowej ............................................ 246
4.24.1. Porz1dkowanie tablicy warto%ci ................................................................. 248
4.25. Tablice wielowymiarowe ..................................................................................... 250
4.25.1. Wierszowy układ elementów tablicy .......................................................... 251
4.25.2. Kolumnowy układ elementów tablicy ........................................................ 255
4.26. Przydział pami0ci dla tablic wielowymiarowych ................................................. 256
4.27. Odwołania do elementów tablic wielowymiarowych w j0zyku asemblerowym... 258
6
Asembler. Sztuka programowania
4.28. Du2e tablice i MASM (tylko dla programistów systemu Windows) .................... 259
4.29. Rekordy (struktury) .............................................................................................. 260
4.30. Stałe rekordowe .................................................................................................... 263
4.31. Tablice rekordów.................................................................................................. 264
4.32. Wykorzystanie tablic i rekordów w roli pól rekordów ......................................... 265
4.33. Ingerowanie w przesuni0cia pól rekordów ........................................................... 269
4.34. Wyrównanie pól w ramach rekordu...................................................................... 270
4.35. WskaIniki na rekordy........................................................................................... 271
4.36. Unie ...................................................................................................................... 273
4.37. Unie anonimowe................................................................................................... 275
4.38. Typy wariantowe .................................................................................................. 276
4.39. Stałe unii............................................................................................................... 277
4.40. Przestrzenie nazw ................................................................................................. 278
4.41. Tablice dynamiczne w j0zyku asemblerowym ..................................................... 281
4.42. Obsługa tablic w bibliotece standardowej j0zyka HLA ........................................ 284
4.43. <ródła informacji dodatkowych............................................................................ 287
Rozdział 5. Procedury i moduły ........................................................................289
5.1. Wprowadzenie ...................................................................................................... 289
5.2. Procedury.............................................................................................................. 289
5.3. Zachowywanie stanu systemu .............................................................................. 292
5.4. Przedwczesny powrót z procedury ....................................................................... 296
5.5. Zmienne lokalne ................................................................................................... 297
5.6. Symbole lokalne i globalne obiektów innych ni2 zmienne ................................... 303
5.7. Parametry.............................................................................................................. 304
5.7.1. Przekazywanie przez warto%E ..................................................................... 305
5.7.2. Przekazywanie przez adres ......................................................................... 308
5.8. Funkcje i warto%ci funkcji .................................................................................... 311
5.8.1. Zwracanie warto%ci funkcji......................................................................... 312
5.8.2. Zło2enie instrukcji j0zyka HLA .................................................................. 313
5.8.3. Atrybut @returns procedur j0zyka HLA..................................................... 316
5.9. Rekurencja............................................................................................................ 318
5.10. Deklaracje zapowiadaj1ce .................................................................................... 322
5.11. Procedury w uj0ciu niskopoziomowym — instrukcja call.................................... 323
5.12. Rola stosu w procedurach..................................................................................... 325
5.13. Rekordy aktywacji................................................................................................ 328
5.14. Standardowa sekwencja wej%cia do procedury ..................................................... 331
5.15. Standardowa sekwencja wyj%cia z procedury ....................................................... 333
5.16. Niskopoziomowa implementacja zmiennych automatycznych ............................ 334
5.17. Niskopoziomowa implementacja parametrów procedury..................................... 336
5.17.1. Przekazywanie argumentów w rejestrach ................................................... 337
5.17.2. Przekazywanie argumentów w kodzie programu........................................ 340
5.17.3. Przekazywanie argumentów przez stos....................................................... 342
5.18. WskaIniki na procedury ....................................................................................... 365
5.19. Parametry typu procedurowego............................................................................ 368
5.20. Nietypowane parametry wskaInikowe ................................................................. 370
5.21. Zarz1dzanie du2ymi projektami programistycznymi............................................ 371
5.22. Dyrektywa #include ............................................................................................. 372
5.23. Unikanie wielokrotnego wł1czania do kodu tego samego pliku........................... 374
5.24. Moduły a atrybut @external................................................................................. 375
5.24.1. Działanie atrybutu @external..................................................................... 380
5.24.2. Pliki nagłówkowe w programach HLA....................................................... 382
5.25. Jeszcze o problemie za%miecania przestrzeni nazw .............................................. 384
5.26. <ródła informacji dodatkowych............................................................................ 386
[ Pobierz całość w formacie PDF ]

  • zanotowane.pl
  • doc.pisz.pl
  • pdf.pisz.pl
  • tejsza.htw.pl

    •