Programowanie hybrydowe: C + asembler

Tworzenie i uruchamianie wstawek w asemblerze do programów w języku C z wykorzystaniem Microsoft Visual Studio

Spis treści:

Środowisko
Dokumentacje asemblera nasm i debuggera gdb
Przygotowanie programu w asemblerze, asemblacja i łączenie
Uruchamianie programu w debuggerze

Pozyskać i zainstalować Microsoft Visual Studio: w zasadzie może być dowolna wersja wspierająca C/C++ (w niektórych wersjach C/C++ nie jest domyślnie wybrane), wystarczy Express, ale warto rozważyć nowsze, bardziej rozbudowane wersje, np. darmową Community

Dokumentacje obu narzędzi można znaleźć pod poniższymi adresami::

Przygotowanie projektu:

Przygotowanie programu w asemblerze, asemblacja i łączenie:

dla zainteresowanych: różnice pomiędzy nasmem a masmem to m. in.:
1. nasm jest wrażliwy na wielkość liter,
2. nasm zawsze wymaga używania nawiasów kwadratowych przy adresowaniu pośrednim,
3. nasm nie zapamiętuje typów (db, dw ...), nie obsługuje modeli pamięci i dyrektyw ASSUME

programem demonstracyjnym będzie algorytm Euklidesa obliczania największego wspólnego dzielnika dwóch liczb naturalnych bez użycia operacji dzielenia.
Argumenty przed rozpoczęciem obliczeń muszą się znaleźć w rejestrach ax i bx, możemy:
a) załadować je w kodzie za pomocą rozkazów mov i po każdej zmianie asemblować i konsolidować program
b) zakładać pułapkę przed rozpoczęciem obliczeń i modyfikować zawartość rejestrów
a+b) załadować w kodzie i ewentualnie zastawiać pułapkę jak w poniższym przykładzie:

section	.text
  global _start     ; poczatek programu
_start:             ; etykieta _start jest wymagana przez ld i gdb
    nop             ; konieczny do zastawienia pulapki
    mov ax,3        ; A = 3
    mov bx,5        ; B = 5
while:
    cmp ax,bx       ; tu bedziemy (ewentualnie) zakladac pulapke i zadawac z debuggera parametry
    je end
    jg AgtB
AltB:
    sub bx,ax
    jmp while
AgtB:
    sub ax,bx
    jmp while
end:
    int 3

zapisujemy w pliku np.
```
main.asm
```
asemblujemy nasmem:
```
nasm -f elf main.asm
```
jeśli wszystko pójdzie poprawnie uzyskamy plik:
```
main.o
```
konsolidujemy do pliku wykonywalnego np. main.x:
```
ld -m elf_i386 -o main.x main.o
```
(tutaj moga wystąpić problemy w przypadku braku wsparcia dla 32bitowych narzędzi - ewentualnie trzeba będzie wybrać inny niż elf_i386 np. w Cygwinie i386pe)
jeśli wszystko pójdzie poprawnie uzyskamy plik:
```
main.x
```

Uruchamianie programu w debuggerze:

uruchamiamy gdb i ładujemy main.x:
- albo jednym poleceniem:
```
gdb main.x
```
- albo najpierw
```
gdb
```
  a potem badany program poleceniem file:
```
file main.x
```
(gdb ostrzeże, że nie ma informacji o debugowaniu)

możemy teraz wyświetlić np. 20 początkowych bajtów programu jako instrukcje asemblera korzystając z polecenia disassemble od_etykiety,+ile_bajtów:

disassemble _start,+20

Dump of assembler code from 0x8048060 to 0x8048074:
   0x08048060 <_start+0>:       nop
   0x08048061 <_start+1>:       mov    $0x3,%ax
   0x08048065 <_start+5>:       mov    $0x5,%bx
   0x08048069 <while+0>:        cmp    %bx,%ax
   0x0804806c <while+3>:        je     0x804807a 
   0x0804806e <while+5>:        jg     0x8048075 
   0x08048070 <AltB+0>:         sub    %ax,%bx
   0x08048073 <AltB+3>:         jmp    0x8048069 
End of assembler dump.

domyślnie przyjmowana jest jednak standard AT&T, który możemy zmienić na czas sesji na standard Intel/Microsoft poleceniem:

set disassembly-flavor intel

wyświetlmy teraz jeszcze raz np. 25 bajtow program (disassemble _start,+25):

Dump of assembler code from 0x8048060 to 0x8048079:
   0x08048060 <_start+0>:       nop
   0x08048061 <_start+1>:       mov    ax,0x3
   0x08048065 <_start+5>:       mov    bx,0x5
   0x08048069 <while+0>:        cmp    ax,bx
   0x0804806c <while+3>:        je     0x804807a 
   0x0804806e <while+5>:        jg     0x8048075 
   0x08048070 <AltB+0>:         sub    bx,ax
   0x08048073 <AltB+3>:         jmp    0x8048069 
   0x08048075 <AgtB+0>:         sub    ax,bx
   0x08048078 <AgtB+3>:         jmp    0x8048069 
End of assembler dump.

mamy program wykonywalny ale nie możemy teraz po prostu go uruchomić ponieważ nie ma on żadnego interfejsu do wprowadzania daych i wyprowadzania rezultatu, a więc:
zastawiamy pułapkę na początku programu,
do zastawiania pułapek służy polecenie break, którego parametrem jest etykieta/adres gdzie ma zostać zastawiona pułapka ale uwaga: oczywiste rozwiązanie:
```
break *_start
```
nie zadziała w obecnych wersjach narzędzi ponieważ:
a) nasm nie generuje informacji o liniach dla debuggera
b) gdb nie zatrzymuje się na pierwszej instrukcji
i stąd dodatkowa instrukcja nop (no operation), która przesuwa rzeczywisty początek programu o 1 bajt
zakładamy pułapkę na pierwszej linii prawdziwego programu (mov ax,3):
```
break *_start+1
```
i uruchamiamy program poleceniem:
```
run
```
program zatrzyma się na zastawionej pułapce

możemy teraz wyświetlić go od początku (etykieta _start):

disassemble _start,+28

Dump of assembler code from 0x8048060 to 0x804807c:
   0x08048060 <_start+0>:       nop
=> 0x08048061 <_start+1>:       mov    ax,0x3
   0x08048065 <_start+5>:       mov    bx,0x5
   0x08048069 <while+0>:        cmp    ax,bx
   0x0804806c <while+3>:        je     0x804807a 
   0x0804806e <while+5>:        jg     0x8048075 
   0x08048070 <AltB+0>:         sub    bx,ax
   0x08048073 <AltB+3>:         jmp    0x8048069 
   0x08048075 <AgtB+0>:         sub    ax,bx
   0x08048078 <AgtB+3>:         jmp    0x8048069 
   0x0804807a <end+0>:          int    0x3
End of assembler dump.

zwróćmy uwagę na:
podawane w nawiasach trójkątnych przesunięcia adresów rozkazów
oraz strzałkę (=>) wskazującą bieżącą instrukcję

chcąc założyć pułapkę np. na instrukcji cmp ax,bx sprawdzamy jej przesunięcie (<while+0>) i ustawiamy pułapkę
albo odliczając adres od etykiety _start:
```
break *_start+9
```
albo od etykiety while:
```
break *while
```

do wyświetlenia informacji o pułapkach służy polecenie:

info breakpoint

Num     Type           Disp Enb Address    What
1       breakpoint     keep y   0x08048061 <_start+1>
2       breakpoint     keep y   0x08048069 <while>

pułapkę usuwamy poleceniem delete numer_pułapki np.:

delete 2

możemy teraz sprawdzić zawartość wszystkich rejestrów procesora poleceniem:
```
info register
```
albo konkretnego rejestru np. akumulatora (ax)
```
print $ax
```
(polecenie print ma użyteczne przełączniki /d = wyświetlanie dziesiętne i /x = wyświetlanie szesnastkowe)
zawartość rejestrów modyfikujemy poleceniem set np.:
```
set $ax = 3
set $bx = 5
```
program możemy teraz wznowić poleceniem continue (polecenie run rozpocznie program od początku)
po zakończeniu testowania debugger opuszczamy poleceniem:
```
quit
```
do śledzenia instrukcja po instrukcji wykorzystujemy polecenia:
```
step
```
lub
```
nexti
```
(dopóki nie będziemy wywoływać funkcji oba działają tak samo)
w trakcie odpluskwianie może przydać się wyświetlanie tylko fragmentu programu począwszy od bieżącej pozycji, do tego celu można wykorzystać polecenie display z przełącznikiem /liczba_instrukcjii i wskazaniem jako punktu odniesienia licznika rozkazów (pc = program counter/instruction pointer) np. 3 rozkazów:
```
display /3i $pc
```