Profesjonalne_programowanie_Czesc_2_Mysl_niskopoziomowo_pisz_wysokopoziomowo_propr2.pdf

(242 KB) Pobierz
Profesjonalne programowanie. Część 2. Myśl niskopoziomowo, pisz wysokopoziomowo
IDZ DO
PRZYK£ADOW Y ROZDZIA£
Profesjonalne programowanie.
Czêœæ 2. Myœl niskopoziomowo,
pisz wysokopoziomowo
SPIS TREœCI
KATALOG KSI¥¯EK
Autor: Randall Hyde
T³umaczenie: Miko³aj Szczepaniak, Tomasz ¯mijewski
ISBN: 83-246-0463-4
Format: B5, stron: 640
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Napisz wydajny i prawid³owo zoptymalizowany kod
Poznaj zasady programowania w asemblerze.
Wybierz odpowiednie typy danych dla swoich aplikacji.
Naucz siê stosowaæ w³aœciwe mechanizmy obliczeniowe.
Wydajnoœæ to jedna z najwa¿niejszych cech aplikacji tworzonych przez profesjonalistów.
Nale¿y j¹ uwzglêdniaæ od samego pocz¹tku prac nad aplikacj¹. Tymczasem jêzyki
wysokiego poziomu i szybkie procesory sprawi³y, ¿e dziœ programiœci k³ad¹ niewielki
nacisk na wydajnoœæ. Jednak Ÿle dobrane typy danych i niew³aœciwie u¿yte instrukcje
jêzyka wysokiego poziomu mog¹ spowodowaæ, ¿e kod maszynowy powsta³y w wyniku
kompilacji nie bêdzie dzia³aæ odpowiednio szybko. Utworzenie optymalnego i wydajnego
programu mo¿e znacznie u³atwiæ wiedza o tym, jak kod wysokiego poziomu zostanie
przekszta³cony w kod maszynowy.
W ksi¹¿ce „Profesjonalne programowanie. Czêœæ 2. Myœl niskopoziomowo, pisz
wysokopoziomowo” znajdziesz wyczerpuj¹ce informacje dotycz¹ce wyboru typów
danych i maksymalizowania wydajnoœci aplikacji. Nauczysz siê dobieraæ odpowiednie
instrukcje jêzyka wysokiego poziomu tak, aby kompilatory optymalizuj¹ce mog³y na ich
podstawie generowaæ wydajny kod maszynowy. Poznasz tak¿e elementy asemblera
procesorów 80x86 i PowerPC w zakresie niezbêdnym do czytania ze zrozumieniem
kodu generowanego przez kompilator.
Asembler procesorów 80x86 i PowerPC
Przebieg procesu kompilacji
Formaty plików wykonywalnych
Analiza wyników kompilacji
Organizacja pamiêci w trakcie dzia³ania programu
Sposoby przechowywania ró¿nych typów danych w pamiêci
Optymalizacja wyra¿eñ arytmetycznych
Struktury steruj¹ce, funkcje i procedury
Poznaj sposób dzia³ania kompilatorów i popraw wydajnoœæ swoich aplikacji
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ONOWOœCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
430717378.002.png 430717378.003.png 430717378.004.png 430717378.005.png
Podziękowania ................................................................................. 11
Wstęp .............................................................................................. 13
Rozdział 1. Myśl niskopoziomowo, koduj wysokopoziomowo ................................ 17
1.1. Nieporozumienia dotyczące jakości kompilatorów ...............................................18
1.2. Dlaczego nadal warto uczyć się asemblera? ..........................................................18
1.3. Czemu znajomość asemblera nie jest absolutnie niezbędna? .................................19
1.4. Myśl niskopoziomowo ...........................................................................................19
1.4.1. Kompilatory są tylko tak dobre,
jak dobry kod do interpretacji otrzymują ...................................................20
1.4.2. Pomóżmy kompilatorowi generować lepszy kod maszynowy ...................20
1.4.3. Jak myśleć o asemblerze, pisząc programy
w językach wysokiego poziomu? ...............................................................21
1.5. Pisanie kodu wysokopoziomowego .......................................................................23
1.6. Założenia ................................................................................................................23
1.7. Niezależność od konkretnego języka .....................................................................24
1.8. Cechy kodu doskonałego ........................................................................................24
1.9. Wymagane środowisko ..........................................................................................25
1.10. Dodatkowe informacje ...........................................................................................26
Rozdział 2. A może warto poznać asemblera? ..................................................... 27
2.1. Kłody rzucane pod nogi uczącym się asemblera ....................................................27
2.2. Tom drugi Profesjonalnego programowania spieszy z odsieczą ............................28
2.3. Wysokopoziomowe asemblery przychodzą z pomocą ...........................................29
2.4. Asembler wysokopoziomowy (HLA) ....................................................................30
2.5. Myśl na wysokim poziomie, pisz na niskim ..........................................................31
2.6. Paradygmat programowania w asemblerze (myślenie na niskim poziomie) .........32
2.7. Asembler. Sztuka programowania i inne materiały ...............................................34
Rozdział 3. Asembler 80x86 dla zwykłego programisty ........................................ 37
3.1. Dobrze poznać jakiś asembler, ale jeszcze lepiej poznać ich kilka ........................38
3.2. Składnia asemblera 80x86 ......................................................................................38
3.3. Podstawy architektury 80x86 .................................................................................39
3.3.1. Rejestry .......................................................................................................39
3.3.2. Rejestry ogólnego przeznaczenia ...............................................................40
3.3.3. Rejestr EFLAGS .........................................................................................41
3.4. Literały stałych .......................................................................................................42
3.4.1. Literały binarne ..........................................................................................42
3.4.2. Literały dziesiętne ......................................................................................42
430717378.001.png
4
Profesjonalne programowanie. Część 2. Myśl niskopoziomowo, pisz wysokopoziomowo
3.4.3. Literałyszesnastkowe.................................................................................43
3.4.4. Literały znakowe i łańcuchowe ..................................................................44
3.4.5. Liczboweliterałyzmiennoprzecinkowe .....................................................45
3.5. Stałe symboliczne w asemblerach ..........................................................................45
3.5.1. Stałe symboliczne w HLA ..........................................................................46
3.5.2. Stałe symboliczne w Gas ............................................................................46
3.5.3. Stałe symboliczne w MASM i TASM .......................................................46
3.6. Tryby adresowania 80x86 ......................................................................................47
3.6.1. Tryby adresowania rejestrów 80x86 ..........................................................47
3.6.2. Bezpośrednie podawanie wartości .............................................................48
3.6.3. Tryb adresowania z przesunięciem ............................................................49
3.6.4. Tryb adresowania pośredniego przez rejestr ..............................................50
3.6.5. Indeksowany tryb adresowania ..................................................................51
3.6.6. Skalowane tryby adresowania z indeksowaniem .......................................53
3.7. Deklarowanie danych w językach asemblerowych ................................................55
3.7.1. Deklarowanie danych w HLA ....................................................................55
3.7.2. Deklarowanie danych w MASM i TASM ..................................................56
3.7.3. Deklarowanie danych w Gas ......................................................................57
3.7.4. Dostęp do zmiennych bajtowych ................................................................57
3.8. Określanie wielkości operandów w asemblerze .....................................................59
3.8.1. Wymuszanie typów w HLA .......................................................................60
3.8.2. Wymuszanie typu w MASM i TASM ........................................................60
3.8.3. Wymuszanie typu w Gas ............................................................................61
3.9. Minimalny zestaw instrukcji 80x86 .......................................................................61
3.10. Dodatkowe informacje ...........................................................................................61
Rozdział 4. Asembler PowerPC dla zwykłego programisty .................................... 63
4.1. Dobrze poznać jakiś asembler, ale jeszcze lepiej poznać ich kilka ........................64
4.2. Składniaasemblera .................................................................................................64
4.3. Podstawy architektury PowerPC ............................................................................64
4.3.1. Rejestry ogólnego przeznaczenia ...............................................................65
4.3.2. Zmiennoprzecinkowe rejestry ogólnego przeznaczenia .............................65
4.3.3. Rejestry ogólnego przeznaczenia dostępne w trybie użytkownika ............65
4.4. Literałystałych .......................................................................................................68
4.4.1. Literałybinarne ..........................................................................................68
4.4.2. Literałydziesiętne ......................................................................................69
4.4.3. Literałyszesnastkowe.................................................................................69
4.4.4. Literały znakowe i łańcuchowe ..................................................................69
4.4.5. Literałyzmiennoprzecinkowe ....................................................................69
4.5. Stałe symboliczne w asemblerze ............................................................................70
4.6. Tryby adresowania PowerPC .................................................................................70
4.6.1. Tryby adresowania rejestrów PowerPC .....................................................70
4.6.2. Bezpośrednie podawanie wartości .............................................................70
4.6.3. Tryby adresowania pamięci PowerPC ........................................................71
4.7. Deklarowanie danych w językach asemblerowych ................................................72
4.8. Określanie wielkości operandów w asemblerze .....................................................74
4.9. Minimalny zestaw instrukcji ..................................................................................75
4.10. Dodatkowe informacje ...........................................................................................75
Rozdział 5. Narzędzia do analizy wyników kompilacji ........................................... 77
5.1. Typy plików używanych w językach programowania ...........................................78
5.2. Pliki z kodem źródłowym .......................................................................................78
5.2.1. Pliki źródłowe podzielone na elementy ......................................................78
5.2.2. Specjalne formaty kodu źródłowego ..........................................................79
Spis treści
5
5.3. Rodzaje procesorów języków komputerowych ......................................................80
5.3.1. Czyste interpretery ......................................................................................80
5.3.2. Interpretery .................................................................................................80
5.3.3. Kompilatory................................................................................................80
5.3.4. Kompilatoryprzyrostowe ...........................................................................81
5.4. Procestranslacji ......................................................................................................82
5.4.1. Analiza leksykalna i tokeny ........................................................................84
5.4.2. Parsowanie (analiza składniowa) ...............................................................85
5.4.3. Generowanie kodu pośredniego .................................................................86
5.4.4. Optymalizacja .............................................................................................87
5.4.5. Porównanie optymalizacji różnych kompilatorów .....................................97
5.4.6. Generowanie kodu natywnego ...................................................................97
5.5. Wynikikompilacji ..................................................................................................97
5.5.1. Generowanie przez kompilator kodu źródłowego ......................................98
5.5.2. Generowanieprzezkompilator kodu asemblera ..........................................99
5.5.3. Generowanie przez kompilator kodu pośredniego ...................................100
5.5.4. Generowanie przez kompilator plików wykonywalnych .........................101
5.6. Formaty plików z kodem pośrednim .....................................................................101
5.6.1. Nagłówek pliku COFF .............................................................................102
5.6.2. Nagłówek opcjonalny COFF ....................................................................104
5.6.3. Nagłówki sekcji COFF .............................................................................107
5.6.4. SekcjeCOFF ............................................................................................109
5.6.5. Sekcjarelokacji ........................................................................................109
5.6.6. Informacje o symbolach i dla programu uruchomieniowego ...................110
5.6.7. Więcej o formatach plików z kodem pośrednim ......................................110
5.7. Formaty plików wykonywalnych .........................................................................110
5.7.1. Strony, segmenty i wielkość pliku ............................................................111
5.7.2. Fragmentacjawewnętrzna ........................................................................113
5.7.3. Po co zatem w ogóle oszczędzać miejsce? ...............................................113
5.8. Wyrównanie danych i kodu w pliku z kodem pośrednim ....................................115
5.8.1. Dobór wielkości wyrównania sekcji ........................................................116
5.8.2. Łączeniesekcji .........................................................................................117
5.8.3. Sterowanie wyrównaniem sekcji ..............................................................117
5.8.4. Wyrównanie sekcji a moduły biblioteczne ...............................................118
5.9. Konsolidatory i ich wpływ na kod .......................................................................125
5.10. Dodatkowe informacje .........................................................................................128
Rozdział 6. Narzędzia do analizy wyników kompilacji ......................................... 129
6.1. Tytułemwstępu ....................................................................................................130
6.2. Nakazywanie kompilatorowi generowania kodu asemblerowego .......................131
6.2.1. Asembler z kompilatorów GNU i Borlanda .............................................131
6.2.2. Kod asemblerowy z Visual C++ ..............................................................132
6.2.3. Przykładowy kod asemblerowy ................................................................132
6.2.4. Analiza asemblerowych wyników kompilacji ..........................................141
6.3. Analiza wyników kompilacji za pomocą narzędzi do kodu pośredniego ............142
6.3.1. Narzędzie dumpbin.exe Microsoftu .........................................................142
6.3.2. Program FSF/GNU objdump.exe .............................................................154
6.4. Użycie deasemblerów do analizy wyników kompilacji .......................................158
6.5. Użycie programu uruchomieniowego do analizy wyników kompilacji ...............161
6.5.1. Użycie programu uruchomieniowego z IDE ............................................161
6.5.2. Użycie samodzielnego programu uruchomieniowego .............................162
6.6. Porównywanie wyników dwóch kompilacji ........................................................164
6.6.1. Porównywanie wersji za pomocą narzędzia diff ......................................164
6.6.2. Porównywanieręczne...............................................................................173
6.7. Dodatkoweinformacje .........................................................................................174
6
Profesjonalne programowanie. Część 2. Myśl niskopoziomowo, pisz wysokopoziomowo
Rozdział 7. Stałe a języki wysokiego poziomu ................................................... 175
7.1. Literały stałych a wydajność programu ................................................................176
7.2. Literały stałych a stałe deklarowane ....................................................................178
7.3. Wyrażeniastałe ....................................................................................................179
7.4. Stałe deklarowane a obiekty w pamięci tylko do odczytu ...................................181
7.5. Typywyliczeniowe ..............................................................................................182
7.6. Stałelogiczne .......................................................................................................184
7.7. Stałezmiennoprzecinkowe ...................................................................................186
7.8. Stałełańcuchowe ..................................................................................................191
7.9. Stałe typów złożonych ..........................................................................................195
7.10. Dodatkowe informacje .........................................................................................196
Rozdział 8. Zmienne w językach wysokiego poziomu ......................................... 197
8.1. Organizacja pamięci w trakcie działania programu .............................................197
8.1.1. Sekcje kodu, stałych i danych tylko do odczytu ...........................................198
8.1.2. Sekcja zmiennych statycznych .................................................................200
8.1.3. SekcjaBSS ...............................................................................................201
8.1.4. Sekcjastosu ..............................................................................................202
8.1.5. Sekcja sterty i dynamiczna alokacja pamięci ...........................................203
8.2. Czym jest zmienna? ..............................................................................................204
8.2.1. Atrybuty....................................................................................................204
8.2.2. Wiązanie ...................................................................................................204
8.2.3. Obiektystatyczne .....................................................................................204
8.2.4. Obiektydynamiczne .................................................................................205
8.2.5. Zakres .......................................................................................................205
8.2.6. Czasżycia .................................................................................................205
8.2.7. Czym zatem jest zmienna? .......................................................................206
8.3. Zmienne w pamięci ..............................................................................................206
8.3.1. Wiązanie statyczne i statyczne zmienne ...................................................206
8.3.2. Wiązanie pseudostatyczne i zmienne automatyczne ................................210
8.3.3. Wiązanie dynamiczne i zmienne dynamiczne ..........................................213
8.4. Typowe elementarne typy danych ........................................................................217
8.4.1. Zmienne całkowitoliczbowe .....................................................................217
8.4.2. Zmienne zmiennoprzecinkowe, czyli rzeczywiste ...................................220
8.4.3. Zmienneznakowe.....................................................................................221
8.4.4. Zmiennelogiczne .....................................................................................222
8.5. Adresy zmiennych a języki wysokiego poziomu .................................................222
8.5.1. Alokacja pamięci na zmienne globalne i statyczne ..................................223
8.5.2. Użycie zmiennych automatycznych w celu zmniejszenia przesunięć .....224
8.5.3. Alokacja pamięci na zmienne pośrednie ..................................................230
8.5.4. Alokacja pamięci na zmienne dynamiczne i wskaźniki ...........................231
8.5.5. Użycie rekordów (struktur) do zmniejszenia przesunięć .........................233
8.5.6. Zmiennerejestrowe ..................................................................................235
8.6. Wyrównanie zmiennych w pamięci .....................................................................236
8.6.1. Rekordy i wyrównanie .............................................................................241
8.7. Dodatkoweinformacje .........................................................................................246
Rozdział 9. Tablicowe typy danych ................................................................... 249
9.1. Czymjesttablica? ................................................................................................249
9.1.1. Deklarowanietablic ..................................................................................250
9.1.2. Zapis tablic w pamięci ..............................................................................254
9.1.3. Dostęp do elementów tablicy ...................................................................257
9.1.4. Dopełnianie a kodowanie .........................................................................259
9.1.5. Tablicewielowymiarowe .........................................................................262
9.1.6. Tablice dynamiczne a tablice statyczne ...................................................275
9.2. Dodatkoweinformacje .........................................................................................284

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin