Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00373 008920 10486914 na godz. na dobę w sumie
Asembler. Podręcznik programisty - książka
Asembler. Podręcznik programisty - książka
Autor: Liczba stron: 640
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-797-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> asembler - programowanie
Porównaj ceny (książka, ebook, audiobook).

Tajniki tworzenia programów dla systemu Windows w asemblerze

Pisanie programów w asemblerze przez długi czas kojarzyło się z systemem MS-DOS. Teraz asembler powoli odzyskuje straconą pozycję języka programowania dla systemu Windows. Wśród wielu zalet asemblera można wymienić: bezpośredni dostęp do procesora, zwarty i niewielki kod wynikowy oraz możliwości trudne do uzyskania za pomocą języków wysokiego poziomu. Asembler jest niezbędny przy tworzeniu sterowników dla urządzeń zewnętrznych, a korzystanie z niego uczy myślenia algorytmicznego, od którego języki obiektowe stopniowo odzwyczajają programistów.

Książka 'Asembler. Podręcznik programisty' to kompendium wiedzy dotyczącej pisania programów dla systemu Windows w języku asemblera. Znajdziesz w niej opisy narzędzi programistycznych i sposoby korzystania z procedur Windows API. Nauczysz się tworzyć programy dla Windows -- od najprostszych, wykorzystujących konsolę, aż do skomplikowanych aplikacji z interfejsem graficznym. Dowiesz się, jak korzystać z narzędzi do wykrywania i usuwania błędów, a także poznasz zasady stosowania asemblera w połączeniu z językami wysokiego poziomu.

Odkryj nieznane obszary programowania -- poznaj język asemblera

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Asembler. Podrêcznik programisty Autor: Vlad Pirogow T³umaczenie: Wojciech Moch ISBN: 83-7361-797-3 Tytu³ orygina³u: The Assembly Programming Master Book Format: B5, stron: 640 Tajniki tworzenia programów dla systemu Windows w asemblerze • Poznaj narzêdzia programistyczne • Napisz programy wykorzystuj¹ce Windows API • Wykryj i usuñ b³êdy z programów asemblerowych Pisanie programów w asemblerze przez d³ugi czas kojarzy³o siê z systemem MS-DOS. Teraz asembler powoli odzyskuje stracon¹ pozycjê jêzyka programowania dla systemu Windows. Wġród wielu zalet asemblera mo¿na wymieniæ: bezpoġredni dostêp do procesora, zwarty i niewielki kod wynikowy oraz mo¿liwoġci trudne do uzyskania za pomoc¹ jêzyków wysokiego poziomu. Asembler jest niezbêdny przy tworzeniu sterowników dla urz¹dzeñ zewnêtrznych, a korzystanie z niego uczy myġlenia algorytmicznego, od którego jêzyki obiektowe stopniowo odzwyczajaj¹ programistów. Ksi¹¿ka „Asembler. Podrêcznik programisty” to kompendium wiedzy dotycz¹cej pisania programów dla systemu Windows w jêzyku asemblera. Znajdziesz w niej opisy narzêdzi programistycznych i sposoby korzystania z procedur Windows API. Nauczysz siê tworzyæ programy dla Windows — od najprostszych, wykorzystuj¹cych konsolê, a¿ do skomplikowanych aplikacji z interfejsem graficznym. Dowiesz siê, jak korzystaæ z narzêdzi do wykrywania i usuwania b³êdów, a tak¿e poznasz zasady stosowania asemblera w po³¹czeniu z jêzykami wysokiego poziomu. • Narzêdzia programistyczne dla systemu Windows • Wywo³ywanie funkcji Windows API • Programy dzia³aj¹ce w trybie tekstowym • Tworzenie i wykorzystywanie zasobów • Praca z systemem plików • Tworzenie bibliotek DLL • Programowanie sieciowe • Wykorzystywanie asemblera w jêzykach wysokiego poziomu • Turbo Debugger • Tworzenie sterowników Odkryj nieznane obszary programowania -- poznaj jêzyk asemblera Spis treści Wstęp ...................................................o........................................... 9 Część I Podstawy programowania 32-bitowego w systemach Windows ..................................................13 Rozdział 1. Narzędzia programistyczne dla systemu Windows ............................ 15 Pierwszy program w asemblerze i jego przekształcenia ................................................. 15 Moduły obiektowe ...................................................p...................................................p.... 20 Dyrektywa INVOKE ...................................................p...................................................p 22 Dane w module obiektowym ...................................................p....................................... 24 Asemblacja programem TASM ...................................................p................................... 25 Uproszczony tryb segmentacji ..................................................p...................................... 26 Inne narzędzia używane do pracy z asemblerem ...................................................p......... 27 Edytory ...................................................p...................................................p............... 28 Programy uruchomieniowe ...................................................p................................... 28 Deasemblery ...................................................p...................................................p....... 29 Edytory szesnastkowe ...................................................p........................................... 31 Kompilatory zasobów ...................................................p........................................... 31 Edytory zasobów ...................................................p...................................................p 31 Rozdział 2. Podstawy programowania w systemie Windows ............................... 33 Wywoływanie funkcji API ...................................................p.......................................... 34 Struktura programu ..................................................p...................................................p.... 37 Rejestracja klasy okna ...................................................p........................................... 37 Tworzenie okna ...................................................p...................................................p.. 37 Pętla obsługi komunikatów ...................................................p................................... 37 Procedura okna głównego ...................................................p..................................... 38 Przykłady prostych programów okienkowych ...................................................p............. 39 Jak to zrobić w asemblerze TASM32? ...................................................p........................ 45 Przekazywanie parametrów poprzez stos ...................................................p.................... 49 Rozdział 3. Proste programy w języku asemblera ............................................... 53 Zasady budowania aplikacji w systemie Windows ...................................................p...... 53 Okno z przyciskiem ...................................................p...................................................p.. 55 Okno z polem edycyjnym ...................................................p............................................ 59 Okno z listą ...................................................p...................................................p.............. 65 Okna potomne i okna posiadane ...................................................p.................................. 72 4 Asembler. Podręcznik programisty Rozdział 4. Przegląd programowania 16-bitowego .............................................. 81 Zasady programowania 16-bitowego w systemie Windows ........................................... 81 Przykład aplikacji 16-bitowej ...................................................p................................ 83 Rozdział 5. Asemblery MASM i TASM ...................................................o............ 89 Opcje wiersza poleceń asemblerów ml.exe i tasm32.exe ............................................... 89 Opcje wiersza poleceń konsolidatorów link.exe i tlink32.exe ........................................ 92 Dołączanie do plików wykonywalnych informacji dla programu uruchomieniowego ... 97 Tworzenie aplikacji konsolowych i aplikacji z interfejsem GUI .................................... 99 Konsolidacja automatyczna ...................................................p......................................... 99 Programy same tłumaczące się na kod wynikowy ...................................................p 99 Część II Programowanie w systemie Windows ...........................101 Rozdział 6. Kodowanie tekstu w systemie Windows ........................................ 103 Kodowanie informacji tekstowych ...................................................p............................ 103 OEM i ANSI ...................................................p...................................................p.......... 104 Unikod ...................................................p...................................................p.................... 105 Rozdział 7. Przykłady prostych programów ...................................................o... 109 Wypisywanie tekstu w oknie ...................................................p..................................... 109 Wybieranie czcionki ...................................................p.................................................. 122 Grafika ..................................................p...................................................p..................... 128 Rozdział 8. Aplikacje konsolowe ...................................................o.................. 139 Tworzenie konsoli ...................................................p...................................................p.. 143 Przetwarzanie zdarzeń klawiatury i myszy ...................................................p................ 147 Czasomierz w aplikacji konsolowej ...................................................p.......................... 154 Rozdział 9. Idea zasobów — edytory i kompilatory zasobów ............................. 161 Język opisu zasobów ...................................................p................................................. 161 Ikony ...................................................p...................................................p................ 162 Kursory ...................................................p...................................................p............ 164 Bitmapy ...................................................p...................................................p............ 165 Ciągi znaków ..................................................p...................................................p..... 165 Dialogi ...................................................p...................................................p............. 165 Menu ...................................................p...................................................p................ 170 Klawisze skrótów ...................................................p................................................ 175 Niemodalne okna dialogowe ...................................................p..................................... 177 Kompilowanie zasobów i konsolidowanie plików obiektowych w pakiecie TASM32 ...................................................p......................................... 182 Rozdział 10. Przykłady programów korzystających z zasobów ............................. 185 Dynamiczne menu ...................................................p...................................................p.. 185 Klawisze szybkiego dostępu ..................................................p....................................... 195 Zarządzanie listami ...................................................p...................................................p. 201 Programowanie w stylu Windows XP ...................................................p....................... 207 Rozdział 11. Praca z plikami ...................................................o.......................... 213 Charakterystyki plików ...................................................p............................................. 213 Atrybuty plików ...................................................p.................................................. 214 System plików FAT32 ...................................................p............................................... 217 System plików NTFS ...................................................p................................................ 220 Katalogi w systemie plików NTFS ................................................p......................... 223 Kompresja plików w systemie NTFS ...................................................p.................. 224 Spis treści 5 Punkty dołączania ...................................................p............................................... 224 Wyszukiwanie plików ...................................................p......................................... 225 Asemblacja programu za pomocą asemblera TASM ............................................. 240 Techniki pracy z plikami binarnymi ...................................................p.......................... 240 Jak pobrać atrybuty pliku? ...................................................p.................................. 251 Część III Bardziej skomplikowane przykłady programów dla systemu Windows ..................................................255 Rozdział 12. Dyrektywy i makroinstrukcje języka asemblera .............................. 257 Etykiety ...................................................p...................................................p.................. 257 Struktury ...................................................p...................................................p................. 259 Unie ...................................................p...................................................p........................ 260 Wygodna metoda pracy ze strukturami ...................................................p..................... 260 Asemblacja warunkowa ..................................................p.............................................. 261 Wywołania procedur ...................................................p................................................. 262 Makroinstrukcje powtórzeń ...................................................p....................................... 263 Makroinstrukcja definiowana ...................................................p.................................... 264 Kilka innych dyrektyw i operatorów asemblera ...................................................p........ 266 Konstrukcje typu HLL ...................................................p............................................... 267 Konstrukcje warunkowe ...................................................p...................................... 267 Pętla WHILE ...................................................p...................................................p.... 268 Tworzenie programów asemblowanych zarówno przez asembler MASM, jak i asembler TASM ...................................................p.............................................. 269 Rozdział 13. Więcej o zarządzaniu plikami ...................................................o...... 271 Dokładny opis funkcji CreateFile ...................................................p.............................. 271 Inne możliwości funkcji CreateFile ...................................................p........................... 275 Skrytki pocztowe ...................................................p................................................. 276 Potoki ...................................................p...................................................p............... 281 Napędy dyskowe ...................................................p................................................. 282 Przegląd funkcji API zajmujących się zarządzaniem plikami ...................................... 286 Asynchroniczne wejście i wyjście ...................................................p............................. 287 Rozdział 14. Przykłady programów korzystających z czasomierza ....................... 293 Najprostszy przykład użycia czasomierza ...................................................p................. 295 Interakcja między czasomierzami ..................................................p............................... 299 Okna dymków pomocy ..................................................p............................................... 305 Rozdział 15. Wielozadaniowość ...................................................o..................... 317 Tworzenie procesu ...................................................p...................................................p. 317 Wątki ...................................................p...................................................p...................... 327 Komunikacja między wątkami ...................................................p.................................. 333 Semafory ...................................................p...................................................p................334 Zdarzenia ...................................................p...................................................p................ 336 Sekcje krytyczne ...................................................p...................................................p.... 336 Wzajemne wykluczenie ...................................................p............................................. 346 Rozdział 16. Tworzenie bibliotek dynamicznych (DLL) ........................................ 347 Koncepcje ogólne ...................................................p...................................................p... 347 Tworzenie biblioteki dynamicznej ...................................................p............................ 349 Konsolidacja niejawna ...................................................p.............................................. 354 Korzystanie ze wspólnej przestrzeni adresowej ...................................................p........ 356 Współdzielenie pamięci przez kilka procesów ...................................................p.......... 364 6 Asembler. Podręcznik programisty Rozdział 17. Programowanie sieciowe ...................................................o............ 369 Urządzenia sieciowe ...................................................p.................................................. 369 Wyszukiwanie i podłączanie dysków sieciowych ...................................................p..... 374 Słowo o protokołach sieciowych TCP/IP ...................................................p.................. 387 Model OSI ...................................................p...................................................p........ 387 Rodzina protokołów TCP/IP ...................................................p............................... 387 Adresowanie w protokole IP ...................................................p............................... 389 Maski adresów ...................................................p...................................................p. 391 Adresy fizyczne i adresy protokołu IP ...................................................p................ 391 Usługa systemu nazw domen ...................................................p.............................. 391 Automatyczne przypisywanie adresów protokołu IP ............................................. 392 Routing ...................................................p...................................................p............. 392 Zarządzanie gniazdami ...................................................p.............................................. 393 Przykład aplikacji najprostszego serwera i klienta ...................................................p.... 397 Rozdział 18. Rozwiązywanie problemów związanych z programowaniem w systemie Windows ...................................................o................. 411 Umieszczanie ikony na tacce systemowej ...................................................p................. 411 Przetwarzanie plików ...................................................p................................................ 417 Kontrolowanie danych w polu edycyjnym ...................................................p................ 419 Wymiana danych pomiędzy aplikacjami ...................................................p................... 427 Zabezpieczenie przed wielokrotnym uruchomieniem aplikacji .................................... 433 Operacje na grupach plików i katalogów ...................................................p.................. 434 Drukowanie ...................................................p...................................................p............ 436 Korzystanie z listy zadań ...................................................p........................................... 436 Część IV Debugowanie, analiza kodu i przygotowywanie sterowników ...................................443 Rozdział 19. Programowanie systemowe ...................................................o........ 445 Adresowanie stron i segmentów ...................................................p................................ 445 Przestrzeń adresowa procesu ...................................................p..................................... 450 Zarządzanie pamięcią ...................................................p................................................ 452 Haki ...................................................p...................................................p........................ 458 Rozdział 20. Wykorzystywanie asemblera w językach wysokiego poziomu .......... 467 Koordynacja wywołań ...................................................p............................................... 467 Koordynacja nazw ...................................................p...................................................p.. 468 Koordynacja parametrów ...................................................p.......................................... 469 Prosty przykład wykorzystania asemblera w językach wysokiego poziomu ................ 470 Borland C++ 5.0 ...................................................p.................................................. 470 Visual C++ 7.0 ...................................................p...................................................p. 471 Delphi 7.0 ...................................................p...................................................p......... 473 Przekazywanie parametrów przez rejestry ..................................................p.................. 474 Wywołania funkcji API i zasoby w modułach asemblera ............................................ 475 Połączenie języka C z kodem asemblerowym ...................................................p........... 480 Asembler wbudowany ...................................................p............................................... 486 Przykład wykorzystania biblioteki dynamicznej ...................................................p....... 488 Rozdział 21. Programowanie usług ...................................................o................. 493 Podstawowe koncepcje i funkcje kontrolne ...................................................p............... 493 Struktura usługi ...................................................p...................................................p...... 495 Przykładowa usługa ...................................................p...................................................p 501 Spis treści 7 Rozdział 22. Programy uruchomieniowe i deasemblery ....................................... 515 Narzędzia firmy Microsoft ...................................................p........................................ 515 editbin.exe ...................................................p...................................................p........ 515 dumpbin.exe ...................................................p...................................................p..... 517 Narzędzia innych producentów ...................................................p................................. 519 dumppe.exe ...................................................p...................................................p...... 519 hiew.exe ...................................................p...................................................p........... 519 dewin.exe ...................................................p...................................................p......... 522 IDA Pro ...................................................p...................................................p............ 522 Rozdział 23. Wprowadzenie do programu Turbo Debugger .................................. 525 Debugowanie programów napisanych w językach wysokiego poziomu ...................... 529 Technika debugowania ...................................................p.............................................. 531 Rozdział 24. Praca z deasemblerem W32Dasm i programem uruchomieniowym SoftIce ......................................... 533 Program uruchomieniowy W32Dasm ...................................................p....................... 533 Rozpoczęcie pracy ...................................................p.............................................. 533 Nawigowanie po deasemblowanym kodzie ...................................................p........ 535 Wyświetlanie danych ...................................................p.......................................... 536 Wypisywanie importowanych i eksportowanych funkcji ....................................... 536 Wyświetlanie zasobów ...................................................p........................................ 537 Operacje na tekstach ...................................................p........................................... 537 Ładowanie programów do debugowania ...................................................p............. 538 Praca z bibliotekami dynamicznymi ...................................................p................... 539 Punkty wstrzymania ...................................................p............................................ 539 Modyfikowanie kodu, danych i rejestrów ...................................................p........... 540 Dodatkowe możliwości pracy z funkcjami API ...................................................p.. 541 Wyszukiwanie w programie potrzebnych lokalizacji ............................................. 541 Debuger SoftIce ...................................................p...................................................p...... 542 Instalacja ...................................................p...................................................p.......... 543 Ładowanie programu do debugowania ...................................................p............... 543 Przegląd poleceń programu uruchomieniowego ...................................................p. 544 Rozdział 25. Podstawy analizy kodu ...................................................o............... 549 Zmienne i stałe ...................................................p...................................................p....... 549 Struktury sterujące języka C ...................................................p...................................... 553 Konstrukcje warunkowe ...................................................p...................................... 553 Zagnieżdżone konstrukcje warunkowe ...................................................p............... 554 Operator Switch ...................................................p.................................................. 555 Pętle ...................................................p...................................................p................. 556 Zmienne lokalne ...................................................p.................................................. 557 Funkcje i procedury ..................................................p.............................................. 559 Optymalizacja kodu ...................................................p...................................................p 560 Prędkość albo rozmiar ...................................................p......................................... 562 Optymalizowanie skoków warunkowych ...................................................p............ 563 Optymalizowanie wywołań procedur ...................................................p.................. 563 Programowanie zorientowane obiektowo ...................................................p.................. 564 Rozdział 26. Korygowanie modułów wykonywalnych .......................................... 569 Praktyczny przykład korygowania modułu wykonywalnego ....................................... 569 Wyszukiwanie procedury okna ...................................................p................................. 572 8 Asembler. Podręcznik programisty Rozdział 27. Struktura sterowników i ich tworzenie ........................................... 575 Wirtualne sterowniki urządzeń ...................................................p.................................. 575 Opis projektu ...................................................p...................................................p.... 577 Prosty sterownik ...................................................p.................................................. 581 Dynamiczne sterowniki wirtualne ...................................................p....................... 583 Podstawowe pojęcia sterowników trybu jądra ...................................................p........... 589 Jądro systemu operacyjnego i struktura pamięci ...................................................p. 590 Kontrolowanie sterowników ...................................................p............................... 591 Przykład prostego sterownika trybu jądra ...................................................p........... 592 Sterowniki i urządzenia trybu jądra ...................................................p..................... 605 Dodatki ...................................................d...................................615 Bibliografia ...................................................o................................ 617 Skorowidz ...................................................o.................................. 619 Rozdział 1. Narzędzia programistyczne dla systemu Windows W niniejszym rozdziale przedstawię krótkie wprowadzenie do kwestii związanych z narzędziami wykorzystywanymi w czasie programowania w asemblerze. Rozdział ten przeznaczony jest dla początkujących, dlatego doświadczeni programiści mogą go z czystym sumieniem pominąć. Na początek trzeba zauważyć, że tytuł tego rozdziału jest nieco zwodniczy, ponieważ techniki asemblacji w systemie MS-DOS i Windows są do siebie bardzo podobne. Mi- mo to programowanie w systemie MS-DOS jest już właściwie odległą przeszłością. Pierwszy program w asemblerze i jego przekształcenia Na rysunku 1.1 przedstawiono schemat przekształceń pojedynczego modułu w języku asemblera. Z etapami przekształceń przedstawionymi na rysunku 1.1 związane są dwa specjalne programy: asembler1 ml.exe i konsolidator link.exe (a jeżeli korzystamy z pakietu Turbo Assembler, to odpowiednio programy tasm32.exe i tlink32.exe). Załóżmy, że plik źró- dłowy z programem w języku asemblera nazywa się prog.asm. Bez zagłębiania się m 1 Programiści praktycznie od zawsze nazywali programy tłumaczące kod w języku asemblera asemblerami, a nie kompilatorami. 16 Część I ♦ Podstawy programowania 32-bitowego w systemach Windows Rysunek 1.1. Schemat przekształceń modułu asemblerowego w szczegóły można powiedzieć, że pierwszy etap przekształceń, który nazywać będzie- my asemblacją lub po prostu tłumaczeniem, wykonywany jest poniższym poleceniem: E OCUO DKP ONEEQHHRTQICUO W wyniku działania tego polecenia powstanie plik obiektowy prog.obj. W drugim etapie przekształceń nazywanym konsolidacją lub łączeniem, wykorzystamy go w po- leceniu: E OCUO DKP NKPMUWDU[UVGOYKPFQYURTQIQDL W wyniku jego działania otrzymamy plik wykonywalny prog.exe. Myślę, że nietrudno domyślić się znaczenia opcji E oraz EQHH programu ml.exe i opcji UWDU[UVGOYKPFQYU programu link.exe. Pozostałe opcje tych programów ze szczegółami opisane będą w rozdziale 5. Im więcej zastanawiam się nad tym dwuetapowym schematem przekształceń, tym bar- dziej wydaje mi się on doskonały. Format wynikowego modułu jest zależny od syste- mu operacyjnego. Po określeniu wymagań struktury modułu obiektowego uzyskujemy następujące możliwości:   zastosowanie gotowych do użycia modułów obiektowych, konsolidacja programów napisanych za pomocą kilku różnych języków programowania. Jednak główną zaletą jest możliwość stosowania standardu modułów obiektowych dla innych systemów operacyjnych. Oznacza to, że będziemy mogli wykorzystać też mo- duły przygotowane w innych systemach operacyjnych2. W celu zobrazowania procesu asemblacji i konsolidacji kodu źródłowego zaprezentu- ję teraz kilka programów, które tak naprawdę nie robią nic użytecznego. Na listingu 1.1 przedstawiony został program „Nie rób nic”. Zapiszemy go w pliku prog1.asm. Zaznaczam teraz, że we wszystkich przykładowych programach instruk- cje mikroprocesora i dyrektywy asemblera pisane będą 9+ .-+/+.+6 4#/+. m 2 Tego rodzaju przenośność ma jednak pewne ograniczenia, ponieważ spore trudności może sprawiać koordynacja wywołań systemowych w poszczególnych systemach operacyjnych. Rozdział 1. ♦ Narzędzia programistyczne dla systemu Windows 17 Listing 1.1. Program „Nie rób nic” 2 Płaski model pamięci /1 .(.#6UVFECNN -------------------------------- Segment danych A #6#5 )/ 06 A #6# 0 5 Segment kodu A6 :65 )/ 06 56#46 4 6Wyjście A6 :6 0 5 0 56#46 Teraz, wykonując poniższe polecenia, przekształcimy nasz program w moduł wyko- nywalny3: ONEEQHHRTQICUO NKPMUWDU[UVGOYKPFQYURTQIQDL Korzystając jednak z pakietu Turbo Assemblera, należy zastosować poniższe polecenia: VCUOONRTQICUO VNKPMCCRTQIQDL Na razie proszę nie zagłębiać się w zbytnio w przedstawione przykłady przekształceń. Bardzo często wygodnym rozwiązaniem jest podzielenie kodu źródłowego na kilka części i łączenie ich w pierwszym etapie przekształceń. Na taki zapis kodu źródłowe- go programów pozwala dyrektywa +0 .7 . Na przykład w jednym z plików można umieścić kod programu, a w drugim — stałe i dane (takie jak definicje zmiennych) wraz z prototypami procedur zewnętrznych. Takie pliki bardzo często opatrywane są rozszerzeniem .inc. Ta metoda podziału programu przedstawiona została na listingu 1.2. Listing 1.2. Zastosowanie dyrektywy INCLUDE Plik CONS.INC 105 37 105 37 105 37 105 37 105 37 105 37 105 37 105 37 105 37 105 37 m 3 Jeżeli nazwy asemblowanych i konsolidowanych modułów zawierają w sobie spacje, to muszą być one zamknięte pomiędzy znakami cudzysłowu: ONEEQHHOÎLRKGTYU[RTQITCOCUO 18 Część I ♦ Podstawy programowania 32-bitowego w systemach Windows 105 37 105 37 Plik DAT.INC #6 914  #6 914  #6 914  #6 914  #6 914  #6 914  #6 914  #6 914  #6 914  #6 914  #6 914  #6 914  Plik progl.asm 2 Płaski model pamięci /1 .(.#6UVFECNN Dołączenie pliku ze stałymi +0 .7  105+0 ------------------------------------------------------ Segment danych A #6#5 )/ 06 Dołączenie pliku z danymi +0 .7  #6+0 A #6# 0 5 Segment kodu A6 :65 )/ 06 56#46 /18 #: 105 5*. #:Mnożenie przez 2 /18 #6 #: ----------------------------------- /18 #: 105 5*. #:Mnożenie przez 4 /18 #6 #: ----------------------------------- /18 #: 105 #  #:Dodanie wartości 1000 /18 #6 #: ----------------------------------- /18 #: 105 #  #:Dodanie wartości 2000 /18 #6 #: ----------------------------------- /18 #: 105 57$ #:Odjęcie wartości 3000 /18 #6 #: ----------------------------------- /18 #: 105 57$ #:Odjęcie wartości 4000 /18 #6 #: ----------------------------------- /18 #: 105 /18 : Rozdział 1. ♦ Narzędzia programistyczne dla systemu Windows 19 +/7. :Mnożenie przez 3 /18 #6 #: ----------------------------------- /18 #: 105 /18 :Mnożenie przez 7 +/7. : /18 #6 #: ----------------------------------- /18 #: 105 /18 $:Dzielenie przez 3 /18 : + +8 $: /18 #6 #: ----------------------------------- /18 #: 105 /18 $:Dzielenie przez 7 /18 : + +8 $: /18 #6 #: ----------------------------------- /18 #: 105 5*4 #:Dzielenie przez 2 /18 #6 #: ----------------------------------- /18 #: 105 5*4 #:Dzielenie przez 4 /18 #6 #: ----------------------------------- 4 6Wyjście A6 :6 0 5 0 56#46 Podobnie jak wszystkie przykładowe programy z tego rozdziału program przedsta- wiony na listingu 1.2 nie ma większego sensu. Doskonale demonstruje jednak możli- wości, jakie udostępnia nam dyrektywa +0 .7 . Ponownie proszę o nieskupianie się na wszystkich instrukcjach mikroprocesora przedstawianych w przykładach. Na razie interesować nas będzie tylko instrukcja + +8. W naszym programie instrukcja + +8 wykonuje operacje dzielenia parametru umiesz- czonego w parze rejestrów : #:. Wpisując do rejestru : zero, powodujemy, że dzielona będzie tylko liczba zapisana w rejestrze #:. Asemblacja i konsolidacja programu wykonywane jest programami MASM lub TASM zgodnie z podanymi wcześniej wskazówkami. Typy danych W niniejszej książce najczęściej będziemy korzystać z trzech głównych typów da- nych: bajtu (byte), słowa (word) i podwójnego słowa (double word). Powszechnie stosowana jest następująca metoda zapisu tych typów: bajt — $;6 lub $, słowo — 914 lub 9, podwójne słowo — 914 lub . Wybór jednej z metod zapisu (w jednym miejscu piszę $, a w innym $;6 ) dyktowany był chęcią uwypuklenia pewnych funkcji języka i zróżnicowania zapisu. 20 Część I ♦ Podstawy programowania 32-bitowego w systemach Windows Moduły obiektowe Wyjaśnię teraz, dlaczego w etapie konsolidacji konieczne jest dołączanie innych mo- dułów obiektowych i bibliotek. Po pierwsze, trzeba wspomnieć, że niezależnie od liczby łączonych ze sobą modułów, tylko jeden z nich może być modułem głównym. Wynika to z bardzo prostej zasady mówiącej, że modułem głównym jest ten, od któ- rego rozpoczyna się wykonywanie programu. Jest to jedyna różnica pomiędzy modu- łem głównym a pozostałymi. Trzeba też pamiętać o tym, że moduł główny w punkcie startowym segmentu musi mieć zdefiniowaną etykietę 56#46. Należy wypisać ją rów- nież po dyrektywie 0 , ponieważ w ten sposób informujemy asembler, żeby wpisał dane punktu wejścia programu do nagłówka ładowanego modułu. Z reguły wszystkie procedury wywoływane w danym module umieszczane są w mo- dułach dołączanych dyrektywą +0 .7 . Przyjrzyjmy się takiemu modułowi przedsta- wionemu na listingu 1.3. Listing 1.3. Moduł prog2.asm przechowujący procedurę proc1 wywoływaną z modułu głównego 2 Moduł prog2 Płaski model pamięci /1 .(.#6UVFECNN 27$.+ 241  A6 :65 )/ 06 241 241 /18 #: 4 6 241  0 2 A6 :6 0 5 0 Przede wszystkim proszę zauważyć, że po dyrektywie 0 nie ma żadnej etykiety. Jak widać, z pewnością nie jest to moduł główny, ale zawarte w nim procedury będą wy- woływane z innych modułów. Innym ważnym elementem, na który chciałbym zwrócić uwagę, jest to, że procedura w tym module musi zostać zadeklarowana ze słowem kluczowym 27$.+ . Nazwa tej procedury zostanie zapisana w module obiektowym, dzięki czemu będzie można ją łączyć z wywołaniami z innych modułów. Możemy więc uruchomić następujące polecenie: ONEQHHERTQICUO W wyniku działania tego polecenia powstanie moduł prog2.obj. Przeprowadzimy teraz małe śledztwo. Proszę przejrzeć zawartość pliku obiektowego za pomocą najprostszej przeglądarki, takiej jak wbudowana w menedżer plików Far.exe. Zapewne bardzo szybko zauważymy, że zamiast nazwy 241  w pliku tym zapisana jest nazwa A241  . Znaki, o których teraz będzie mowa, mają bardzo duże znacze- nie, dlatego należy dobrze zapamiętać te informacje! Po pierwsze, znajdujący się na Rozdział 1. ♦ Narzędzia programistyczne dla systemu Windows 21 początku znak podkreślenia (A) oznacza, że stosowany jest standard ANSI, który wy- maga, aby wszystkie nazwy publiczne (w tym i nazwy udostępniane innym modułom) były automatycznie uzupełniane o znak podkreślenia. W tym przypadku, zajął się tym za nas program asemblera. Przyrostek  jest już nieco bardziej złożony. Przede wszystkim musimy wiedzieć, co oznacza ta kombinacja znaków. Liczba podana za znakiem oznacza liczbę bajtów, jakie należy odłożyć na stos przed wywołaniem procedury. W tym przypadku asem- bler stwierdził, że procedura nie wymaga podawania żadnych parametrów. Taki zapis wprowadzony został w ramach opisywanej dalej dyrektywy +081- stosowanej do wy- godnego wywoływania procedur. Teraz spróbujemy przygotować główny moduł pro- gramu o nazwie prog1.asm — listing 1.4. Listing 1.4. Moduł prog1.asm wywołujący procedurę z modułu prog2.asm 2 Płaski model pamięci /1 .(.#6UVFECNN -------------------------------- Prototyp procedury zewnętrznej :6 40241  0 #4 Segment danych A #6#5 )/ 06 A #6# 0 5 Segment kodu A6 :65 )/ 06 56#46  #..241   4 6Wyjście A6 :6 0 5 0 56#46 Jak widać, procedura wywoływana z innego modułu zadeklarowana jest z dyrektywą :6 40. Co więcej, nazwa tej procedury musi być uzupełniona o przyrostek opisujący wielkość parametrów procedury, czyli nie można podać nazwy 241 , ale nazwę 241  . Na razie nic nie można w tym zmienić. Mogą pojawić się natomiast pytania o parametr 0 #4. W systemie MS-DOS parametr ten oznaczał, że wywołanie procedury (lub skok bezwarunkowy) będzie odbywało się wewnątrz jednego segmentu. Z drugiej strony parametr (#4 oznaczał, że wywołanie procedury (lub skok) będzie wykonywane z in- nego segmentu. W systemie Windows stosowany jest tak zwany płaski (Flat) model pamięci, w którym cała pamięć traktowana jest jako jeden wielki segment, dlatego na- turalnym wydaje się zastosowanie parametru 0 #4. Możemy teraz wykonać następujące polecenie: ONEQHHERTQICUO W wyniku otrzymamy moduł obiektowy prog1.obj. Połączmy więc dwa przygotowa- ne moduły, tworząc końcowy program wykonywalny o nazwie prog1.exe: NKPMUWDU[UVGOYKPFQYURTQIQDLRTQIQDL W czasie łączenia modułów jako pierwsza musi być podana nazwa modułu głównego, a nazwy pozostałych modułów można podawać za nią w dowolnej kolejności. 22 Część I ♦ Podstawy programowania 32-bitowego w systemach Windows Dyrektywa INVOKE Przyjrzyjmy się teraz dyrektywie +081- . Jest to bardzo wygodne polecenie, jednak z powodów, o których powiem później, osobiście korzystam z niego niezwykle rzadko. Główna zaleta dyrektywy +081- polega na tym, że pozwala ona pominąć z nazw pro- cedur przyrostek 0. Po drugie, dyrektywa sama zajmuje się załadowaniem odpowied- nich parametrów na stos przed wywołaniem procedury. Dzięki temu nie trzeba stoso- wać poniższej sekwencji poleceń: 275*RCT 275*RCT 275*RCT 275*RCT #..0# 9#A241 74; 0N — liczba bajtów do zapisania na stos Zamiast nich wystarczy wpisać jedną dyrektywę: +081- 0# 9#A241 74;RCTRCTRCTRCT Jako parametry można w niej podawać rejestry, wartości bezpośrednie lub adresy. Po- dając adres, można zastosować zarówno operator 1((5 6, jak i # 4. Zmodyfikujmy teraz moduł prog1.asm (modułu prog2.asm nie trzeba modyfikować) tak, jak pokazano na listingu 1.5. Listing 1.5. Stosowanie dyrektywy INVOKE 2 Płaski model pamięci /1 .(.#6UVFECNN -------------------------------- Prototyp procedury zewnętrznej 241 24161 Segment danych A #6#5 )/ 06 A #6# 0 5 Segment kodu A6 :65 )/ 06 56#46 +081- 241  4 6Wyjście A6 :6 0 5 0 56#46 Doskonale widać, że tym razem zewnętrzna procedura deklarowana jest za pomocą dyrektywy 24161. Dyrektywa ta pozwala na łatwe deklarowanie ewentualnych para- metrów procedury. Na przykład zapis podobny do poniższego: 241 24161 914 914 oznacza, że procedura wymaga podania dwóch parametrów, z których pierwszy ma długość czterech bajtów, a drugi dwóch (co daje w sumie sześć bajtów i może być oznaczone przyrostkiem ). Rozdział 1. ♦ Narzędzia programistyczne dla systemu Windows 23 Jak już mówiłem, z dyrektywy +081- korzystam tylko w wyjątkowych przypadkach. Podam teraz pierwszy z powodów takiego unikania jej stosowania — jestem zdecydo- wanym zwolennikiem czystości języka asemblerowego, w związku z czym nie najle- piej czuję się, stosując w swoich programach jakiekolwiek makroinstrukcje. Uważam też, że początkujący programiści nie powinni zbyt często używać makroinstrukcji w swoich programach, ponieważ w ten sposób nigdy nie będą mogli w pełni docenić piękna tego języka. Jest jeszcze jeden powód mojego unikania makroinstrukcji, ale o nim opowiem nieco później. Według schematu przedstawionego na rysunku 1.1 możliwa jest konsolidacja ze sobą również innych modułów obiektowych i bibliotek. Jeżeli będziemy zmuszeni skorzy- stać z kilku modułów obiektowych, może to być bardzo niewygodne. Z tego powodu takie moduły łączone są w biblioteki. Najprostszą i najwygodniejsza metodą dołącze- nia do programu danej biblioteki w asemblerze MASM jest wykorzystanie dyrektywy +0 .7 .+$. Dyrektywa ta zapisana zostanie w kodzie obiektowym i będzie później wykorzystywa- na przez program link.exe. Jak jednak tworzy się biblioteki z modułów? Do tego zadania użyć należy specjalne- go programu nazywanego bibliotekarzem (ang. librarian). Załóżmy, że chcielibyśmy przygotować bibliotekę lib1.lib składającą się z tylko jednego modułu — prog2.obj. W tym celu należy wywołać następujące polecenie: NKDQWVNKDNKDRTQIQDL Jeżeli w którymś momencie będziemy chcieli dodać do biblioteki dodatkowy moduł (modul.obj), to wystarczy wywołać poniższe polecenie: NKDNKDNKDOQFWNQDL Podam jeszcze dwa przykłady, w których można zastosować program bibliotekarza:   NKDNKUVNKDNKD — polecenie to wypisuje moduły zgromadzone w bibliotece. NKDTGOQXGOQFWNQDLNKDNKD — usuwa z biblioteki lib1.lib moduł modul.obj. Wróćmy teraz do naszego przykładu. Tym razem zamiast modułu obiektowego uży- jemy w programie przygotowanej przed chwilą biblioteki. Na listingu 1.6 pokazano zmodyfikowaną treść programu prog1.asm. Listing 1.6. Wykorzystanie biblioteki 2 Płaski model pamięci /1 .(.#6UVFECNN -------------------------------- Prototyp procedury zewnętrznej :6 40241  0 #4 -------------------------------- +0 .7 .+$.+$.+$ 24 Część I ♦ Podstawy programowania 32-bitowego w systemach Windows -------------------------------- Segment danych A #6#5 )/ 06 A #6# 0 5 Segment kodu A6 :65 )/ 06 56#46  #..241   4 6Wyjście A6 :6 0 5 0 56#46 Dane w module obiektowym Nadszedł czas, żeby przyjrzeć się sposobom wykorzystania danych (zmiennych) zde- finiowanych w innym module obiektowym. Po dokładnym przeczytaniu tego podroz- działu nic nie powinno stanowić już w tym zakresie tajemnicy. Na listingach 1.7 i 1.8 przedstawione zostały moduły prog1.asm i prog2.asm będące demonstracją wykorzy- stania zmiennych zewnętrznych4. Listing 1.7. Moduł przechowujący zmienną ALT wykorzystywaną w module prog1.asm 2 Moduł prog2.asm Płaski model pamięci /1 .(.#6UVFECNN 27$.+ 241  27$.+ #.6 Segment danych A #6#5 )/ 06 #.6 914  A #6# 0 5 A6 :65 )/ 06 241 241 /18 #:#.6 #  #: 4 6 241  0 2 A6 :6 0 5 0 Listing 1.8. Moduł wykorzystujący zmienną ALT zdefiniowaną w module prog2.asm 2 Moduł prog1.asm Płaski model pamięci /1 .(.#6UVFECNN -------------------------------- m 4 Termin „zmienna zewnętrzna” stosowany będzie tu na zasadzie analogii do terminu „procedura zewnętrzna”. Rozdział 1. ♦ Narzędzia programistyczne dla systemu Windows 25 Prototyp procedury zewnętrznej :6 40241  0 #4 Zmienna zewnętrzna :6 40#.6 914 Segment danych A #6#5 )/ 06 A #6# 0 5 Segment kodu A6 :65 )/ 06 56#46 /18#.6  #..241   /18 #:#.6 4 6Wyjście A6 :6 0 5 0 56#46 Proszę zauważyć, że w przeciwieństwie do procedur zewnętrznych zmienne zewnętrzne nie wymagają stosowania przyrostka 0, ponieważ ich wielkość jest znana z góry. Asemblacja programem TASM Spróbujemy teraz przetestować działanie wszystkich zaprezentowanych do tej pory programów, asemblując je tym razem programem tasm. Jeżeli chodzi o programy przedstawione na listingach 1.1 i 1.2 to nie powinniśmy mieć żadnych problemów. W celu ich asemblacji i konsolidacji wystarczy wykonać poniż- sze polecenia: VCUOONRTQICUO VNKPMCCRTQIQDL Spróbujmy teraz przekształcić moduły prog2.asm i prog1.asm, które przedstawiane były na listingach 1.3 i 1.4. Utworzenie modułów obiektów nie powinno nastręczać żadnych problemów, jednak przeglądając zawartość modułu prog2.obj, zauważymy, że nazwa procedury zewnętrznej nie ma żadnych przyrostków, ale wypisana jest w naj- prostszej postaci — RTQE. W związku z tym konieczna jest zmiana nazwy procedury w module prog1.asm z 241   na 241 . Dalsze łączenie tych modułów również nie będzie już sprawiało żadnych kłopotów: VNKPMCCRTQIQDLRTQIQDL Do prac z bibliotekami pakiet TASM udostępnia specjalny program bibliotekarza — tlib.exe. Poniższym poleceniem utworzymy z modułu prog2.obj nową bibliotekę: VNKDNKDNKD RTQIQDL W efekcie wywołania tego polecenia na dysku pojawi się plik biblioteki o nazwie lib1. lib. Teraz możemy połączyć moduł prog1.obj z utworzoną biblioteką: VNKPMCCRTQIRTQIRTQINKD 26 Część I ♦ Podstawy programowania 32-bitowego w systemach Windows W wyniku otrzymamy moduł wykonywalny prog1.exe. Należy zwracać ścisłą uwagę na opcje wiersza poleceń programu tlink32. W najczę- ściej stosowanej formie wyglądają one mniej więcej tak5: VNKPMCCRNKMKAQDLRNKMAGZGRNKMAOCRRNKMKANKD     RNKMKAQDL — jeden lub kilka plików obiektowych (rozdzielanych spacjami); moduł główny musi być wpisany jako pierwszy. RNKMAGZG — plik wykonywalny. RNKMAOCR — plik .map zawierający informacje o strukturze modułu. RNKMKANKD — jedna lub kilka bibliotek (rozdzielanych spacjami). Pakiet TASM nie pozwala na stosowanie dyrektywy +081- , dlatego w kolejnych przy- kładach będę starał się jej unikać6. We wstępie do tej książki zadeklarowałem, że będę próbował jednakowo opisywać oba asemblery. Różnice pomiędzy nimi skupiają się przede wszystkim na dyrektywach i makroinstrukcjach (co zobaczymy w rozdziale 5.), dlatego najprostszym pomysłem na uzyskanie zgodności programów z obydwoma asemblerami jest unikanie stosowa- nia dyrektyw i makroinstrukcji. Podstawę programowania w systemie Windows two- rzą wywołania funkcji API (będzie o nich mowa w rozdziale 2.). Jednak wiemy już, że asemblery różnią się sposobem wywoływania zewnętrznych procedur; MASM wy- maga stosowania przyrostka 0, a TASM obywa się bez niego. W tym zakresie nie uda się nam, niestety, uniknąć stosowania definicji makroinstrukcji. O tym jednak powie- my we właściwym czasie. Uproszczony tryb segmentacji Zarówno asembler MASM, jak i TASM obsługują tak zwaną segmentację uproszczoną. Osobiście wolę klasyczną strukturę programów w języku asemblera, ale muszę przy- znać, że uproszczona segmentacja jest metodą bardzo wygodną, szczególnie w czasie programowania dla systemu Windows. Segmentacja uproszczona polega na tym, że punkt początkowy segmentu kodu ozna- czany jest dyrektywą  1 , natomiast dyrektywa  #6#7 oznacza początek segmentu danych. Obie dyrektywy mogą pojawiać się wewnątrz programu wielokrotnie, a pro- gram asemblera odpowiednio poskłada ze sobą poszczególne segmenty kodu i danych. Głównym zadaniem tego rozwiązania jest umożliwienie umieszczania w kodzie źró- dłowym danych możliwie najbliżej miejsca ich wykorzystania w kodzie programu. Po- m 5 Zaznaczam, że jest to forma nieco uproszczona. 6 Poza tym uważam, że najlepszym rozwiązaniem jest ręczne ładowanie parametrów na stos. 7 Dostępna jest też specjalna dyrektywa opisująca segment stosu — 56# -. Osobiście używam jej jednak wyjątkowo rzadko. Rozdział 1. ♦ Narzędzia programistyczne dla systemu Windows 27 dobne rozwiązanie zostało swego czasu wprowadzone również w języku C++. Według mnie powoduje to jednak znaczące trudności w czasie czytania kodu takiego progra- mu. Poza tym nie chciałbym uchodzić za przesadnego estetę, ale nie podoba mi się program, w którym dane i kod są dowolnie przemieszane ze sobą. Na listingu 1.9 przedstawiono sposób użycia trybu uproszczonej segmentacji. Listing 1.9. Program korzystający z segmentacji uproszczonej 2 Płaski model pamięci /1 .(.#6UVFECNN -------------------------------- Segment danych  #6# 57/ 914  Segment kodu  1 56#46 Segment danych  #6# # 914  Segment kodu  1 /18 #:# Segment danych  #6# $ 914  Segment kodu  1 #  #:$ /1857/ #: 4 6Wyjście 0 56#46 Dyrektywy w rodzaju  #6# i  1 można umieszczać w tradycyjnie zdefiniowanym segmencie kodu. Jest to wygodna metoda tworzenia przydatnych makroinstrukcji, które będą opisywane w rozdziale 12. Inne narzędzia używane do pracy z asemblerem Na zakończenie tego rozdziału przedstawiam krótki opis innych programów często uży- wanych w czasie programowania w języku asemblera. Później część z tych programów będzie opisywana dokładniej, a o pozostałych w ogóle nie będziemy już wspominać. 28 Część I ♦ Podstawy programowania 32-bitowego w systemach Windows Edytory Osobiście w czasie pisania programów asemblerowych nie używam żadnego specjalizo- wanego edytora, ale chcę, aby opisy w tej książce były pełne, dlatego wspomnę tutaj o dwóch takich narzędziach. Na początek zajmiemy się edytorem qeditor.exe dostar- czanym w pakiecie asemblera MASM. Sam edytor, a także towarzyszące mu narzę- dzia, został napisany w asemblerze. Już pobieżna analiza możliwości edytora i jego rozmiaru może budzić uznanie. Jako przykład podam, że sam edytor ma tylko 27 kB, a narzędzie do przeglądania raportów i wyników przekształceń programów — 6 kB. Edytor ten doskonale nadaje się do pracy z niewielkimi aplikacjami mieszczącymi się w pojedynczych modułach. Nie pozwala jednak na wygodną pracę z kilkoma moduła- mi. Działanie edytora opiera się na interakcji kilku narzędzi połączonych ze sobą pli- kami wsadowymi. Na przykład przekształcenia programów przeprowadzane są przez plik wsadowy assmbl.bat, który odpowiednio wywołuje asembler ml.exe, a wyniki je- go działania zapisuje do pliku asmbl.txt. Do przejrzenia zawartości tego pliku koniecz- ne jest użycie programu thegun.exe. Konsolidacja modułów programu wykonywana jest w podobny sposób. Narzędzie dumppe.exe stosowane jest do deasemblowania modułów wykonywalnych, a wyniki tej operacji zapisywane są do pliku disasm.txt. Pozostałe operacje wykonywa- ne są w podobny sposób. Wprowadzając zmiany do poszczególnych plików wsadowych, można modyfikować zachowania poszczególnych narzędzi, a w razie konieczności można nawet zamienić niektóre z używanych narzędzi (na przykład zamiast programu ml.exe zastosować program tasm32.exe). Drugim edytorem, na który chciałbym wskazać, jest program eas.exe (Easy Assembler Shell — prosta powłoka asemblera). Edytor ten, lub, jak wskazuje jego nazwa, po- włoka, pozwala na tworzenie, asemblowanie i konsolidowanie złożonych projektów składających się z plików .asm, .obj, .rc, .res i .def. Program ten może współpracować z asemblerem TASM i MASM, a także z innymi narzędziami, takimi jak programy uruchomieniowe, edytory zasobów itd. Współpraca z asemblerami i konsolidatorami może być przygotowana dzięki opcjom tej powłoki pozwalającym na wprowadzenie opcji wiersza poleceń dla stosowanego narzędzia. Programy uruchomieniowe Programy uruchomieniowe zwane często także debugerami (ang. debuggers) pozwa- lają na wykonywanie programów w trybie krok-po-kroku. W czwartej części książki opisywać będę dokładniej programy uruchomieniowe i deasemblery. Do najpopular- niejszych programów uruchomieniowych8 na rynku należą CodeView firmy Microsoft, Turbo Debugger firmy Borland oraz program Ice9. m 8 Razem z systemem Windows dostarczany jest nadal debuger debug.exe, jednak program ten nie obsługuje najnowszego formatu plików wykonywalnych. 9 Obecnie firma Microsoft udostępnia na swoich stronach internetowych bardzo dobry program uruchomieniowy WinDbg, który przeznaczony jest do pracy pod systemem operacyjnym Windows. Bardzo przyjazny jest z kolei OllyDbg dostępny na stronie autora tego bardzo dobrego programu uruchomieniowego — przyp. red. Rozdział 1. ♦ Narzędzia programistyczne dla systemu Windows 29 Deasemblery Deasemblery konwertują moduły wykonywalne na kod asemblerowy. Przykładem naj- prostszego deasemblera może być program dumppe.exe uruchamiany z poziomu wier- sza poleceń. Na listingu 1.10 przedstawiono przykład wydruku przygotowanego przez program dumppe.exe. Wydruk ten jest wynikiem deasemblowania programu przedsta- wionego na listingu 1.4. Raczej trudno byłoby go rozpoznać… Listing 1.10. Wynik deasemblowania programu wykonanego przez program dumppe.exe MPCGZG JGZ  FGE  : UKG D[VGU  /KPKOWONQCFUKG D[VGU  1XGTNC[PWODGT +PKVKCN 5+2 +PKVKCN5552$ /KPKOWOCNNQECVKQP RCTC  /CZKOWOCNNQECVKQP RCTC (((( *GCFGTUKG RCTC  4GNQECVKQPVCDNGQHHUGV 4GNQECVKQPGPVTKGU 2QTVCDNGGZGEWVCDNGUVCTVUCVC 5KIPCVWTG 2 /CEJKPGN  +PVGN 5GEVKQPU 6KOGFCVGUVCOR#  $9GF#RT 5[ODQNVCDNG 0WODGTQHU[ODQNU 1RVKQPCNJGCFGTUKG  JCTCEVGTKUVKEU( 4GNQECVKQPKPHQTOCVKQPUVTKRRGF ZGEWVCDNGKOCIG .KPGPWODGTUUVTKRRGF .QECNU[ODQNUUVTKRRGF DKVYQTFOCEJKPG /CIKE$ .KPMGTXGTUKQP 5KGQH QFG 5KGQHKPKVKCNKGFFCVC 5KGQHWPKPKVKCNKGFFCVC #FFTGUUQHGPVT[RQKPV $CUGQHEQFG $CUGQHFCVC +OCIGDCUG 5GEVKQPCNKIPOGPV (KNGCNKIPOGPV 1RGTCVKPIU[UVGOXGTUKQP +OCIGXGTUKQP 5WDU[UVGOXGTUKQP 4GUGTXGF +OCIGUKG *GCFGTUKG JGEMUWO 5WDU[UVGO 9KPFQYU 30 Część I ♦ Podstawy programowania 32-bitowego w systemach Windows ..EJCTCEVGTKUVKEU 5KGQHUVCEMTGUGTXG 5KGQHUVCEMEQOOKV 5KGQHJGCRTGUGTXG 5KGQHJGCREQOOKV .QCFGTHNCIU 0WODGTQTFKTGEVQTKGU KTGEVQT[PCOG8KTV#FFT8KTV5KG ōō ZRQTV +ORQTV 4GUQWTEG ZEGRVKQP 5GEWTKV[ $CUGTGNQECVKQP GDWI GUETKRVKQPCTEJKVGEVWTG /CEJKPGXCNWG /+25)2  6JTGCFUVQTCIG .QCFEQPHKIWTCVKQP $QWPFKORQTV +ORQTVCFFTGUUVCDNG GNC[KORQTV 1/TWPVKOGFGUETKRVQT TGUGTXGF  5GEVKQPVCDNG  8KTVWCNCFFTGUU 8KTVWCNUKG 4CYFCVCQHHUGV 4CYFCVCUKG 4GNQECVKQPQHHUGV 4GNQECVKQPEQWPV .KPGPWODGTQHHUGV .KPGPWODGTEQWPV JCTCEVGTKUVKEU QFG ZGEWVCDNG TGCFCDNG KUCUUGODN[ UVCTV  ECNNHPA  TGV  KPV  KPV HPA $ OQXGCZ J   TGV Chciałbym też wspomnieć o deasemblerze W32Dasm, który opiszę ze szczegółami w ostatniej części książki, a także doskonale znanym deasemblerze Ida Pro. W części czwartej przyjrzymy się tym programom dokładniej i omówimy techniki skutecznego ich wykorzystania. Rozdział 1. ♦ Narzędzia programistyczne dla systemu Windows 31 Edytory szesnastkowe Edytory szesnastkowe pozwalają na przeglądanie i edytowanie modułów wykonywal- nych w formacie szesnastkowym. Tego rodzaju edytory wbudowane są w większość popularnych programów uruchomieniowych i deasemblerów. Wspomnę tutaj tylko o programie hiew.exe, bardzo popularnym w środowiskach hakerów. Program ten pozwala na przeglądanie zawartości modułów wykonywalnych zarówno w formacie szesnastkowym, jak i w kodzie asemblerowym. Dodatkowo, oprócz możliwości prze- glądania plików wykonywalnych, program ten pozwala również na ich edycję. Kompilatory zasobów Oba pakiety, MASM i TASM, dostarczane są z kompilatorami zasobów, które będę opisywał w rozdziale 9. Programy te nazywają się odpowiednio rc.exe i brc32.exe. Edytory zasobów Najczęściej korzystam z edytora zasobów dołączanego do pakietu Borland C++ 5.0 albo pochodzącego z pakietu Visual Studio.NET, jednak proste zasoby można tworzyć przy pomocy właściwie dowolnego edytora tekstowego. Język zasobów omawiał bę- dę w rozdziałach 9. i 10.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Asembler. Podręcznik programisty
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: