WAŻNE PRZED ZAKUPEM KSIĄŻEK WYDAWNICTWA HELION PROSZĘ ZAPOZNAĆ SIĘ ZE STRONĄ "O MNIE" Wyjątkowa promocja - szczegóły na końcu strony To już ostatnie sztuki - nie czekaj kup dziś
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
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)
3.4.3. Literały szesnastkowe (43)
3.4.4. Literały znakowe i łańcuchowe (44)
3.4.5. Liczbowe literały zmiennoprzecinkowe (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. Wymuszenie 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ładnia asemblera (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ły stałych (68)
4.4.1. Literały binarne (68)
4.4.2. Literały dziesiętne (69)
4.4.3. Literały szesnastkowe (69)
4.4.4. Literały znakowe i łańcuchowe (69)
4.4.5. Literały zmiennoprzecinkowe (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)
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. Kompilatory przyrostowe (81)
5.4. Proces translacji (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. Wyniki kompilacji (97)
5.5.1. Generowanie przez kompilator kodu źródłowego (98)
5.5.2. Generowanie przez kompilator 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. Sekcje COFF (109)
5.6.5. Sekcja relokacji (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. Fragmentacja wewnętrzna (113)
5.7.3. Po co zatem w ogóle oszczędzać na miejscu? (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. Łączenie sekcji (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łem wstę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ównywanie ręczne (173)
6.7. Dodatkowe informacje (174)
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łe a stałe deklarowane (178)
7.3. Wyrażenia stałe (179)
7.4. Stałe deklarowane a obiekty w pamięci tylko do odczytu (181)
7.5. Typy wyliczeniowe (182)
7.6. Stałe logiczne (184)
7.7. Stałe zmiennoprzecinkowe (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. Sekcja BSS (201)
8.1.4. Sekcja stosu (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. Obiekty statyczne (204)
8.2.4. Obiekty dynamiczne (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. Zmienne znakowe (221)
8.4.4. Zmienne logiczne (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. Zmienne rejestrowe (235)
8.6. Wyrównanie zmiennych w pamięci (236)
8.6.1. Rekordy i wyrównanie (241)
8.7. Dodatkowe informacje (246)
Rozdział 9. Tablicowe typy danych (249)
9.1. Czym jest tablica? (249)
9.1.1. Deklarowanie tablic (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. Tablice wielowymiarowe (262)
9.1.6. Tablice dynamiczne a tablice statyczne (275)
9.2. Dodatkowe informacje (284)
Rozdział 10. Łańcuchowe typy danych (285)
10.1. Formaty łańcuchów znakowych (286)
10.1.1. Łańcuchy zakończone zerem (286)
10.1.2. Łańcuchy poprzedzone długością (302)
10.1.3. Łańcuchy 7-bitowe (304)
10.1.4. Łańcuchy HLA (305)
10.1.5. Łańcuchy oparte na deskryptorach (308)
10.2. Łańcuchy statyczne, pseudodynamiczne i dynamiczne (309)
10.2.1. Łańcuchy statyczne (309)
10.2.2. Łańcuchy pseudodynamiczne (310)
10.2.3. Łańcuchy dynamiczne (310)
10.3. Zliczanie odwołań do łańcuchów (311)
10.4. Łańcuchy w Delphi i Kyliksie (311)
10.5. Korzystanie z łańcuchów w językach wysokiego poziomu (312)
10.6. Dane znakowe w łańcuchach (314)
10.7. Dodatkowe informacje (315)
Rozdział 11. Wskaźnikowe typy danych (317)
11.1. Definiowanie i odkrywanie tajemnic wskaźników (318)
11.2. Implementacje wskaźników w językach wysokopoziomowych (319)
11.3. Wskaźniki i dynamiczny przydział pamięci (322)
11.4. Operacje na wskaźnikach i arytmetyka wskaźników (323)
11.4.1. Dodawanie liczby całkowitej do wskaźnika (324)
11.4.2. Odejmowanie liczby całkowitej od wskaźnika (326)
11.4.3. Odejmowanie wskaźnika od wskaźnika (327)
11.4.4. Porównywanie wskaźników (328)
11.4.5. Stosowanie logicznych operatorów AND i OR dla wskaźników (330)
11.4.6. Pozostałe operatory wskaźnikowe (331)
11.5. Prosty przykład alokatora pamięci (333)
11.6. Odzyskiwanie pamięci (336)
11.7. Przydział pamięci na poziomie systemu operacyjnego (337)
11.8. Dodatkowa złożoność pamięciowa menedżera sterty (338)
11.9. Typowe problemy związane z wskaźnikami (341)
11.9.1. Używanie wskaźnika niezainicjalizowanego (341)
11.9.2. Używanie wskaźnika zawierającego nieprawidłową wartość (342)
11.9.3. Korzystanie z bloku pamięci już po jej zwolnieniu (343)
11.9.4. Zaniedbywanie zwalniania niepotrzebnej pamięci (344)
11.9.5. Uzyskiwanie dostępu do danych za pośrednictwem danych błędnego typu (345)
11.10. Dodatkowe informacje (346)
Rozdział 12. Rekordy, unie i klasowe typy danych (347).... Książka jest wysyłana listem priorytetowym. Zapraszam na moje pozostałe aukcje W chwili obecnej książka jest w cenie 71,20 zł - najniższa cena na Allegro. | 
