Använda GDB för felsökning av Assembly

Välkomna till felsökningens värld! När ni arbetar med lågnivåspråk som assembler är det avgörande att exakt förstå vad programmet gör, instruktion för instruktion.

GNU Debugger (GDB) är ett oerhört kraftfullt verktyg som låter er:

• Pausa programmet vid specifika punkter (brytpunkter).
• Stega genom koden rad för rad.
• Kontrollera värdena i register och minne.
• Förstå programmets flöde och identifiera problem.

Det är en oumbärlig färdighet för alla assemblerprogrammerare!

Innan GDB kan hjälpa oss måste vi kompilera assemblerkoden med särskilda ”debug symbols”. Dessa symboler informerar GDB om variabelnamn, funktionsetiketter och källkodsrader, vilket gör felsökningen mycket enklare.

För NASM-assembler på Linux använder ni vanligtvis flaggan -g under kompilering och länkning:

• Assemblera: nasm -f elf32 -g your_code.asm -o your_code.o
• Länka: ld -m elf_i386 -g your_code.o -o your_executable

Flaggan -g bäddar in felsökningsinformationen direkt i objektfilen och den körbara filen.

Vi använder ett enkelt assemblerprogram som mål för felsökningen. Programmet skriver ut ett meddelande i konsolen och utför sedan en enkel addition innan det avslutas.

Vi kompilerar det med felsökningssymboler och går sedan vidare till GDB.

När programmet har kompilerats med felsökningssymboler är det enkelt att starta GDB. Öppna terminalen och skriv gdb följt av namnet på den körbara filen.

Om den körbara filen i vårt exempel heter debug_executable skriver ni:

gdb ./debug_executable

GDB läser in programmet och visar sin kommandoprompt, vanligtvis (gdb). Programmet körs inte ännu; GDB är bara redo att ta emot kommandon.

En brytpunkt är en markering som instruerar GDB att pausa programmets körning när det når en viss instruktion eller minnesadress. På så sätt stoppar ni programmet vid en intressant punkt.

För att ange en brytpunkt använder ni kommandot break eller b, följt av ett funktionsnamn, en etikett eller en minnesadress. För assembler använder vi ofta etiketter.

• (gdb) break _start: Anger en brytpunkt vid programmets startpunkt.
• (gdb) b *0x80480a0: Anger en brytpunkt vid en specifik minnesadress (exempeladress).

När ni har angett brytpunkter kan ni starta programmet eller återuppta körningen.

• run (eller r): Startar programmet från början. Det körs tills det når den första brytpunkten, avslutas eller kraschar.
• continue (eller c): Återupptar körningen efter att programmet har nått en brytpunkt. Det fortsätter tills nästa brytpunkt eller tills programmet avslutas.

Försök att ange en brytpunkt vid _start och använd sedan run. Då ser ni hur GDB pausar precis i början av programmet!

När programmet har pausats vid en brytpunkt kan ni köra instruktionerna en i taget. Det är ovärderligt för att se den exakta effekten av varje instruktion.

• stepi (eller si): Kör nästa enskilda instruktion. Om instruktionen är ett call till en procedur går si in i den proceduren.
• nexti (eller ni): Kör nästa enskilda instruktion. Om instruktionen är ett call kör ni hela proceduren och stannar vid instruktionen direkt *efter* call.

Använd si för att noggrant följa varje instruktion, eller ni för att hoppa över proceduranrop som ni inte är intresserade av.

Register är processorns små, extremt snabba lagringsplatser. I assembler flyttar ni hela tiden data till och från dem. Med GDB kan ni granska deras aktuella värden.

• info registers (eller i r): Visar de aktuella värdena för alla register för allmän användning, segmentregister, instruktionspekaren (EIP/RIP) och flaggorna.
• info registers eax: Visar värdet för ett specifikt register, till exempel EAX.
• print $eax: Ett annat sätt att skriva ut värdet för ett specifikt register. Prefixet $ talar om för GDB att det är ett register.

Efter instruktionen add eax, ebx kan ni kontrollera eax för att se det nya värdet (15).

Utöver register behöver ni ofta granska vad som finns lagrat i minnet. Kommandot x (examine) är användbart för detta.

Formatet är x/<count><format><unit-size> <address>:

• count (N): Hur många enheter som ska visas.
• format (F): Hur de ska visas (till exempel x för hexadecimalt, d för decimalt, s för sträng och i för instruktioner).
• unit-size (U): Storleken för varje enhet (till exempel b för byte, h för halfword/2 byte, w för word/4 byte och g för giant/8 byte).

Exempel:

• (gdb) x/s hello_msg: Visar strängen vid hello_msg.
• (gdb) x/4xw $esp: Visar 4 word (4 byte vardera) i hexadecimal form med start från stackpekaren.

Ibland felsöker ni och behöver se assemblerinstruktionerna runt den aktuella körningspunkten. Kommandot disassemble (eller disas) omvandlar maskinkod tillbaka till assembler.

• (gdb) disassemble: Demonterar funktionen som körs för närvarande.
• (gdb) disas _start: Demonterar hela funktionen _start.
• (gdb) disas $eip, +20: Demonterar 20 byte instruktioner med start från den aktuella instruktionspekaren (EIP).

Det hjälper er att snabbt orientera er och se sammanhanget i den omgivande koden.

Grattis! Ni har tagit era första steg mot att bemästra GDB för felsökning av assemblerkod. Vi gick igenom:

• varför GDB är nödvändigt för programmering på låg nivå.
• hur man kompilerar assemblerkod med felsökningssymboler.
• grundläggande GDB-kommandon som run, break och continue.
• hur man stegar genom kod med stepi och nexti.
• hur man granskar register (info registers) och minne (x).
• hur man disassemblerar kod under körning (disassemble).

Dessa grundläggande färdigheter hjälper er att förstå och felsöka komplexa assemblerprogram genom att avslöja hur de fungerar, instruktion för instruktion. Fortsätt öva!