Ladění pod UNIXEM - gdb, mtrace
From ωικι.matfyz.cz
Programy a chyby
Toto je referát na seminář linux. Měl by pomoct lidem, kterí se chtějí naučit ladit a nechce se jim (světe div se) číst originální manuál.
http://www.gnu.org/software/gdb/documentation/
Téměř každý program má svoje chyby. Chyby mohou být jak v návrhu(program tak jak je naržen nefunguje správně), tak v realizaci (chyby v kódu). Praktičtější je ovšem chyby rozdělit na chyby "aktivní" a pasivní. Do první skupiny patří chyby patrné na první pohled, tj. program nedělá to co má, nebo padá. Do druhé skupiny patří typicky chyby v alokaci a uvolňování paměti. Druhou skupinu je výrazně obtížnější jak detekovat, tak odhalit.
Fáze ladění kódu
Vytváření a aldění nového software vpostatě probíhá podle následujícího shématu:
DOPSAL JSEM SOFTWARE TESTUJU HO if (V PROGRAMU JE CHYBA) goto ZACATEK LADENI else goto KONEC ZACATEK LADENI STABILIZUJ CHYBU //zajisteni aby se chyba opakovala LOKALIZUJ CHYBU //nalezeni příslušné knihovny, funkce, řádku, kde k chybam dochazi OPRAV CHYBU goto TESTUJ HO KONEC //program je odladěný a můžeme začít s distribucí.
Možnosti ladění kódu
Expertní čtení
Nejjednosušší je tzv "expertní čtení", aneb "Strécu, ono to nefacha, tak se do toho hleď ještě mrknout.". Tohle je jistě možnost, ale má nevýhodu zejména psychologickou, pokud jsme udělali logickou chybu v návrhu, je poměrně těžké ji odstranit jen čtením kódu, protože se ném kód zdá v pořádku. Je to (prý) poměrně funkční v případě, že kód po nás čte někdo jiný.
Ladící výpisy
Asi nejobecnější možnost ladění, funguje skoro vždy a skoro všude. Je dobré vypisovat na stderr, pač jinak pokud něco vypíšete na stdin a program pak "spadne", hláška se může v principu stratit (neměla by, ale experimentálně je tohle tvrzení ověřené). Do programu je možné zařadit výpisy na místa, kde čekáme, že by mohlo dojít k chybě. Docela rozumné může být využít makroprocesoru překladače, napřiklad konstrukcí
#ifdef DEBUG
printf ("hodnota x je : %d\n", x);
#endif
a makro DEBUG si definovat třeba při překladu
$ cc -o sorter -DDEBUG main.c
A jinak v jazyce c/c++ jsou k dispozici makra
| __LINE__ | Číslo aktuální řádky |
| __FILE__ | Jméno souboru |
| __DATE__ | datum, Řetězec formátu "Mmm dd yyyy" |
| __TIME__ | čas, Řetězec formátu "h h : mm : s s" |
Ladící nástroje
Jsou asi neúčinnější formou ladění, (pokud jsou dostupné), pod unixovými systémy je obvykle k dspozici pro ladění chyb, které se projevují db, který má pod linuxem obdobu gdb. Na skryté chyby, např v alokaci paměti jsou k dispozici nástroje typu mtrace, nebo knihovna electric fence (možná pár slov na konci). Program gdb nám umožňuje pozorovat co se děje v "programu vevnitř", popřípadě toto dokonce měnit.
Ukázkový příklad 1.
main.c
#include <stdio.h>
#include <stdlib.h>
#include "qsort.h"
int main(int argc, char ** argv){
int i;
int cisla[] = {10, 12, 2, 4, 8,7, 1, 20, 3, 25};
int * cilsa;
int arrsize = sizeof(cisla) / sizeof(int);
printf("\n\nhello, Im Program for sorting.. ");
printf("\nthis is my input :");
for (i=0; i < arrsize; i++){
printf("%d ",cisla[i] );
}
//tady se to celý děje.
xquickSort(cilsa, arrsize);
printf("\nthis is my output :");
for (i=0; i < arrsize; i++){
printf("%d ",cisla[i] );
}
printf("\nDo you think it's OK?\n");
return 0;
}
qsort.c
void xq_sort(int numbers[], int left, int right){
int pivot, l_hold, r_hold;
l_hold = left;
r_hold = right;
pivot = numbers[left];
while (left < right)
{
while ((numbers[right] >= pivot) && (left < right))
right--;
if (left != right)
{
numbers[left] = numbers[right];
left++;
}
while ((numbers[left] <= pivot) && (left < right))
left++;
if (left != right)
{
numbers[right] = numbers[left];
right--;
}
}
numbers[left] = pivot;
pivot = left;
left = l_hold;
right = r_hold;
if (left < pivot)
xq_sort(numbers, left, pivot-1);
if (right > pivot)
xq_sort(numbers, pivot+1, right);
}
qsort.h
extern void xquickSort(int numbers[], int array_size);
Makefile
EXECUTABLE = sorter
SOURCES = main.c qsort.c
HEADERS = qsort.h
OBJECTS = $(SOURCES:.c=.o)
CC = gcc
CFLAGS = -ggdb -Wall
LDFLAGS = -o
all: $(EXECUTABLE)
clean:
rm *.o $(EXECUTABLE)
$(EXECUTABLE): $(OBJECTS)
$(CC) $(LDFLAGS) $@ $^
$(OBJECTS): $(SOURCES) $(HEADERS)
Překlad programu
Program se nám přeloží bez chyb nebo varování. Je dobré poznamenat,že program je dobé přeložit s parametrem
-g,
nebo pro gdb ještě lépe
-ggdb nebo -ggdb3
. Ty volby se liší ve formátu ladících informací vkládaných do souboru. Do programu takto budou vkládat i některé informace "navíc",které ladícímu prostředku umožní sledovat hromadu věcí, jako jsou třeba jména proměnných a podobně Mimo jiné by šlo ještě poznamenat, že pokud program nechodí tak jak má je dobré ho přeložit s volbou
-Wall -pedantic -ansi
, které nám mohou pomoci odhalit i některé neobyklé konstrukce, často chyby.
Nástroj gdb
gdb je program pro ladění jiných programů. Programy jdou spustit jakoby "v něm". Někdo tvrdí, že je gdb nepřekonatelné... Já bych byl střízlivšjší, pro člověka, který není líný se něco naučit, a je schopen překonat deprese z příkazové řádky je to mocný nástroj.
Co umožňuje gbd
Ladit přeložené programy, zkoumat core-dumpy a připojovat se k běžícím programům. Poslední možnost je docela praktická zvlástě pokud chceme ladit třeba serverové aplikace.
Co se děje při startu gdb
Než začnu rozebírat přikazy pro gdb, pár slov k tomu, co se děje při startu gdb.
- 1gdb se rozběhne v příslušném módu (třeba s gui, nebo v módu silent).. (o gui nic netuším ,ale je to v manuálu)přečte si konfigurák v $HOME
- 2zpracuje argumenty příkazové žádky
- přečte si konfigurák v aktuálním adresáři
- načte histotii příkazů pokud ji máme zapnutou
Konfigurační soubor
A teď k tomu konfiguráku: na linuxu se jemnuje vždycky stejně, .gdbinit a dá se do něj nacpat spoooousta zajímavejch věcí. No třeba ta historie :
set history filename ./.gdb_history set history save on
Docela dobry je si do konfiguraku v daném adresáři dát který soubor bude laděn
file ./sorter
Nebo preloudované knihovny
set env LD_PRELOAD=/usr/lib/libefence.so
Nebo breakpointy
b main
Dají se tem taky definovat makra, ale to je jiná kapitola. Komentáře jsou jako ve skriptech - uvozené #
Spuštění gdb
celá ta nádhera se spustí pomocí příkazu gdb. Volby jsou následující :
| -s file | Ze souboru file se načte tabulka symbolů |
| -e file | Soubor file bude laděn , možno kombinovat se s. |
| -c N | Gdb se připojí k již běžícímu procesu s PID N |
| -c file | Gdb načte core soubor file |
| -x file | Gdb vykoná gdb příkazy v souboru file, něco jako možnost skriptování |
| -d dir | K adresářům, v nichž gdb hledá zdrojové kódy přidá dir |
| -m | Načte symboly do souboru, který pak používá jako tabulku symbolů |
| -r | Načte všechny symboly okamžitě, místo čtení až v případě potřeby |
| -n,-nx | GDB nevykoná žádné příkazy z inicializačních souborů |
| -q | Nevytiskne po spuštění úvodní text a informace o copyrightu |
| -batch | Po vykonání příkazů v souboru -x file vrátí 0, při chybě vrátí nenulové číslo |
| -cd dir | Změní aktuální adresář na dir |
| -f | Vypisuje plné jméno souboru a číslo řádky vždy při zastavení programu |
| -b bps | Nastaví rychlost seriového portu na bps pro vzdálené ladění |
| -tty dev | Přesměruje stdout a stdin laděného programu na dev |
Kdo jste chodila na základy překladačů tak určitě víte co jsou to tabulky symbolů. Je to taková ta chztrá věc, která pojí to jak se proměnná jmenuje, a to jakou má hodnotu. Docela fajn věc pro takové ladění.
Jinak většinou budete startovat gdb příkazem
gdb file
, kde file je jméno laděného programu.
Příkazy v gdb
No a teď zvesela na všechny možný příkazy a fíčury gdb. příkazy se zadávají ručně a gdb si je kompletuje, tj, pokud stisknete
h
a
help
je jediný příkaz začínající na h tak to gdb pochopí. Pokud mu dáváte ještě vybrat,tj. je víc příkazu začínající danou sadou znaků, tak gdb vypíše možnosti.
Příkaz help
První příkaz, který je dobrý znát je vyvolání helpu. help se vyvolá třeba
h
Tenhle příkaz vypíše seznam všech skupin do kterých jsou příkazy dělené.
h <skupina>
zobrazí příkazy ve skupině.
h <prikaz>
zobrazí krátký popis příkazu. Ukázka: Chceme se dozvědět jak se nastavuje breakpoint na nějakou řádku.
(gdb) h aliases -- Aliases of other commands breakpoints -- .... (gdb) h breakpoints awatch -- Set a breakpoint for an expression break -- Set a breakpoint at specified line or function .... (gdb) h break
nám vrátí podrobný popis jak dát breakpoint na řádku
Příkazy k použití pro započetí ladění
Pokud už nám gdb běží (a nespustili jsme ho gdb file) tak musíme specifikovat co se vlastně bude ladit.
| exec-file file | otevře file pro ladìní |
| core-file file | otevře core file |
| attach pid | připojí se k procesu pid |
Programu je možné nastavit argumenty a pracovní adresář.
| set arg | nastaví argumenty programu |
| show arg | zobrazí argumenty programu |
| set environment | nastaví promìnné prostředí |
| show environment | zobrazí promìnné prostøedí |
| cd dir | nastaví adresář dir jako aktuální |
| pwd | zobrazí aktuální adresář |
A potom už mùžeme program vesele spustit, a ladit daný program.
| run | spustí program |
Ukázka:
(gdb) exec-file sorter (gdb) set arg Evzen (gdb) cd ../ (gdb) run
Poznámka: když jsem tohle zkoušel tak se mi to jevilo, jako když gdb nenašel v souboru ladící informace,pokud byl spuštìn bez argumentù a pak mu byl dán pøíkaz exec-file.Že by bug v debuggeru :-) ???
Breakpointy, watchpointy a jiné zastavování běhu programu
Preakpointy a watchpointy jsou místa, kde si přejeme program zastavit. Breakpointy jsou nastavení na nějakou funkci nebo řádek, zatímco watchpointy se vztahují k nějakým proměnným. Co je zajímavý rozdíl, je jak je debugovaní pomocí watchpointù a breakpointů realizované zevnitř. Obě skupiny mohou být realizovány hardwarově a softwarově. Hardwarové řešení vyžaduje podporu hardware, aproto není možné ho zapnout vždy.(softwarově znamená, že do programu je vložena nějaká instrukce, což samo o sobì mùže být značně nežádoucí )Pro hardwarové wp jsou poměrně značné omezení, protože využívali registry, mohou být jen dva a to ještì stejného typu.
Breakpointy
| break, b | nastaví bp na další řádku od aktuální v daném podprogramu (funkci) |
| b funct | nastaví bp na funkci "funct" |
| b N | nastaví bp na řádek N ve zdrojovém kódu |
| b +N, -N | nastaví bp o N řádek dopředu / dozadu od aktuální řádky |
| b file:funct | nastaví bp na funkci funct definovanou v souboru file |
| b file:N | nastaví bp na řádek N v souboru file |
| b *addr | nastaví bp na adresu addr (tohle ja praktické, zvlášť pokud Vás něco vede k ladění programu,přeloženého bez -g) |
| b if cond | nastaví podmíněný bp, tzn. bp zastaví běh programu, pouze je-li splněna podmínka cond |
| tbreak args | nastaví bp se stejnými argumenty jako výše, ale pouze na jedno použití, pak je bp vymazán |
| hbreak args | nastaví hardwarový bp, hw bp musí být podporován hardwarem, oproti klasickému bp nemění
instrukci, na které je nastaven |
| thbreak args | hardwarový tbreak |
| rbreak regex | nastaví bp na všechny funkce, které vyhovují výrazu regex, dodatečně je možno doplnit podmínky a příkazy |
| info breake [n] | zobrazí všechny bp a jejich případné podmínky, je-li specifikováno číslo bp, zobrazí informace pouze o něm |
Watchpointy
K zastavení programu kdykoliv při změně nějaké proměnné je možno použít tzv. watchpointy.
| watch expr | vytvoří wp pro proměnnou expr; gdb zastaví program, kdykoli se obsah proměnné expr změní |
| rwatch expr | program je zastaven, kdykoli je proměnná expr čtena |
| awatch expr | program je zastaven při jakémkoli přístupu k proměnné (r/w) |
| info watchpoints | zobrazí iformace o všech wp, je-li specifikováno číslo wp, vypíše informace pouze o něm |
Vyjímky
Program je možno zastavit i při volání obsluhy výjimky
| catch exeptions | nastaví bp na aktivní obslužné rutiny výjimek, jejichž jména jsou v seznamu exeptions |
| info catch | vypíše všechny aktivní obslužné rutiny vyjímek |
Ukázka:
$ gdb sorter ... (gdb) watch cisla No symbol "cisla" in current context (gdb) break main (gdb) break xquikSort (run)
Nastaví breakpoint na funkce main, a xquicSort, a watchpoint na proměnnou čísla. Ta hláška je logická, proměnná cisla začne mít smysl až po vstupu do funkce main. Po spuštění se program zastaví na funci main, poté pči inicializaci symbolu cisla.
Podmínky pro breakpointy, příkazy pro breakpointy
Poměrně praktické je definovat si podmínky pro breakpointy(tj, bp se bude chovat jako bp pouze pokud je splněna podmínka). Syntax podmínek je převzatý z jazyka c.
| condition bnum expr | nastaví podmínku odpovídající výrazu expr pro bp s číslem bnum |
| condition bnum | zruší podmínku u bp číslo bnum |
Speciální forma podmínky je zastavení až po určitém počtu průchodů.
| ignore bnum count | bp s číslem bnum bude aktivní až po count průchodech (count je integer) |
Navíc pokud jde nastavit i co se má stát, pokud program dorazí k breakpointu, popř pokud je daná podmínka splněna. Syntax je následující:
commands [bnum] <seznam příkazů> end
Ukázka
break xquickSort if numbers == 0 #nastav breakpoint, zastav program pokud numbers == 0 commands silent #nevypisuj informace o provedených operacích set var x = 1 #nastav nějakou porměnnou echo "je to spatny" #něco vypiš cont #pokračuj end
Zpráva breakpointů (vymazání, disalování)
Příkazy clear logicky nefungují na wp.
| clear | vymaže následující bp v aktuálním podprogramu |
| clear funct | vymaže bp na dané funkci |
| clear N | vymaže bp na řádce N |
| clear file:funct | vymaže bp pro funkci funct v souboru file |
| clear file:N | vymaže bp na řádce N v souboru file |
| delete | vymaže všechny bp |
| delete bnums | vymaže bp s čísly v seznamu bnums |
| disable | vypne všechny bp |
| disable bnums | vypne bp s čísly v seznamu bnums |
| enable | zapne všechny bp |
| enable bnums | zapne bp s čísly v seznamu bnums |
| enable once [bnums] | zapne bp pouze na jedno použití - buď všechny, nebo bp s čísly bnums |
| enable delete [bnums] | zapne bp pouze na jedno použití, pak bp smaže všechny, nebo bp s čísly bnums |
Ukázka
(gdb) info watch Num Type Disp Enb Address What 1 watchpoint keep y cisla 2 hw wachpoint keep y i 3 breakpoint keep y 0x08048394 in main at main.c 11 (gdb) clear main (gdb) delete 1 2 (gdb) info watch No breakpoints or watchpoints
Krokování programu
Je-li program zastaven, může být krokován nebo pokračovat ve svém běhu. K těmto účelům slouží tyto příkazy:
| step [N] | vykoná jeden nebo N řádek, je-li volána funkce, příkaz pokračuje uvnitř této funkce - zanoří se |
| next [N] | vykoná jeden nebo N řádek bez zanoření |
| finish | dokončí aktuální stack frame a vytiskne návratovou hodnotu |
| until | zastaví vykonávání programu až na další řádce, dobré pro smyčky |
| until location | zastaví vykonávání programu až na řádce odpovídající location (číslo řádky, jméno funkce) |
| stepi | provede jednu strojovou instrukci s případným zanořením |
| nexti | provede jednu strojovou instrukci bez zanoření |
| continue | pokračuje ve vykonávání programu až do dalšího zastavení (např bp.) |
| continue N | ignoruje N krát daný breakpoint |
| jump cislo | skočí na řádek cislo |
| jump *addr | skočí na adresu addr |
Zobrazení zdrojového kódu přímo v programu gdb
Pokud opravdu pracujeme v konzoli, tak je docela praktické si prohlédnout zdrojový kód programu, pokud jsme se nejakým způsobem zastavili na proglematickém místě. K tomuto účelu slouží příkaz list.
| list | vypíše 10 řádek zdrojového kódu, počínaje aktuální řádkou, opakováním tohoto příkazu se vypíše dalších 10 řádek |
| list - | vypíše 10 řádek zdrojového kódu před aktuální řádkou včetně |
| list N | vypíše 10 řádek zk počínaje řádkou N |
| list funct | vypíše 10 řádek zk počínaje první řádkou definice funkce funct |
| list *addr | vypíše řádek zk, který obsahuje adresu addr |
| list first, last | vypíše zdrojový kód od řádky first do řádky last |
| list ,last | vypíše zdrojový kód od aktuální řádky do řádky last |
| list first, | vypíše zdrojový kód od řádky first do aktuální řádky |
| set listsize N | změní vypisovaný počet řádek na N |
| show listsize | zobrazí, kolik řádek se bude vypisovat |
| search regexp | vypíše následující řádek, na kterém najde regexp |
| reverse-search regexp | vypíše předchozí řádek,na kterém najde regexp |
Ukázka
(gdb)search printf
23 printf("\nthis is my input: ");
Zobrazování kódu programu v asembleru
Zobrazování kódu programu v asembleru Pro opravdové labužníky je možnost vypisovat si program přímo v asembleru. Tahle možnost pracuje jen pokud je program přeložen s ladícími informacemi(nevíte někdo proč??). Pokud nemáme ladící informace k dispozici, můžeme ještě zkusit vypisovat přímo paměť a nechat jí interpretovat jako instrukce, ale to je opravdu hodně pokročilá a nejistá věc.
Zkoumání obsahu paměti programu
Formát dat
gdb musí v některých případech vědět, v jakém formátu má zobrazit data. toto shrnuje následující tabulka:
| x | vypíše obsah jako číslo v hexadecimální soustavě |
| d | vypíše obsah jako číslo se znaménkem v decimální soustavě |
| u | vypíše obsah jako číslo bez znaménka v decimální soustavě |
| o | vypíše obsah jako číslo v oktalové soustavě |
| t | vypíše obsah jako číslo v binární soustavě |
| a | vypíše obsah jako adresu |
| c | vypíše obsah jako znak |
| f | vypíše obsah jako číslo s plovoucí čárkou |
| i | vypíše obsah jako instrukci v assembleru |
Délky datové buňky
Pokud vypisujeme data z adresy, tak je potřeba definovat, jak dlouhá data chceme interpretovat. Délky můžeme nastavit na:
| b | 8 bitů |
| h | 16 bitů |
| w | 32 bitů |
| g | 64 bitů |
Zobrazování hodnot proměnných (print)
Nejčastěji se budeme chtít zobrazit proměnnou a její hodnotu. K tomu nám posloží příkazy:
| print exp | vypíše hodnotu proměnné nebo výrazu exp |
| print/F exp | vypíše hodnotu proměnné nebo výrazu exp ve formátu F |
Automatické zobrazování hodnot proměnných (display)
Pokud tuto akci chceme automatizovat, tj pokud chceme nějaká data zobrazit pokaždém zastavení programu na bp nebo wpje pro nás připraven příkaz display
| display/F addr | nastaví zobrazování obsahu adresy addr ve formátu F při každém zastavení programu, parametr s, který zobrazí obsah adresy jako řetězec |
| display | vypíše všechny hodnoty existujících "zobrazovačů" |
| undisplay dnums, delete display dnums | smaže "zobrazovače" s čísly dnums |
| disable display dnums info line N | vypne "zobrazovače" s čísly dnums |
| enable display dnums info line *addr | zapne "zobrazovače" s čísly dnums |
| info display | vypíše informace o existujících "zobrazovačích" |
Přímý přístup k datům (x, eXamine)
Nejsurovější možností přístupu k datům programu je příkaz x, který sahá doslova a do písmene přímo na data.
| x/NFU addr | vypíše obsah adresy addr ve formátu NFU, kde N určuje, kolikrát se má příkaz opakovat, F je formátovací znak, U je velikost datového typu pro danou adresu |
Ukázka v programu máme pole integerů. pokud chceme vypsat celé pole použijeme příkaz print
(gdb) print cisla
$2 = {10, 12, 2, 4, 8, 7, 1, 20, 3, 25}
a teď k nim přistoupíme pomocí příkazu x
(gdb) x/10uw $2
Práce s daty na zásobníku, trasování
Pro většinu z Vás asi nebude překvapením, že realizace programu (většinou) probíhá pomocí zásobníku. Při volání funkce se na zásobník uloží její parametry, návratová hodnota, lokální proměnné a adresa, na které je funkce právě vykonávána. Čím později je funkce volána, tím blíže k vrcholu zásobníku jsou tyto údaje uloženy. Stack frame je název pro tato data vážící se k právě jedné volané funkci. Při spuštění programu existuje pouze jeden stack frame pro funkci main. Při každém volání další funkce vzniká nový stack frame. Stack frame je jednoznačně určen svojí adresou. V době vykonávání stack framu je jeho adresa obvykle uchovávána ve frame pointer registru. Tolik teorie,a teď jak se to dá použít Gdb přiřazuje každému stack framu unikátní číslo, nulu pro nejvnitřnější sf, tj. ten, který byl volán naposledy. Jednička náleží sf, ze kterého byl poslední volán, atd. U některých kompilátorů je možno vypnout používání sf. Gdb má omezené možnosti pro ladění takovýchto programů. Následuje seznam příkazů pro manipulaci se stack framy:
| frame args | přesun z jednoho sf do jiného a jeho tisk, args může být adresa sf nebo číslo, není-li
argument uveden, vytiskne se aktuální sf |
| select-frame | přesun z jednoho sf do jiného bez tisku |
| bt, bt N | back trace - vytiskne N nejvnitřnějších sf |
| bt -N | vytiskne N nejvnějšnějších sf |
| up | přesun o jeden sf výše (do volajícího sf) |
| down | přesun o jeden sf níže |
| info frame | vytiskne podrobné informace o sf |
| info args | zobrazí argumenty aktuálního sf |
| info locals | zobrazí lokální proměnné aktuálního sf |
| info catch | vytiskne aktivní obsluhy výjimek v aktuálním sf |
K nucenému návratu z funkce lze použít příkaz return expr. Příkaz danou funkci nedokončí, ale zruší daný stack frame a všechny, které z něj byly volány. Je-li uveden výraz expr, vyhodnotí se a výsledek je použit jako návratová hodnota. Následuje návrat za místo volání dané funkce.
Ladění proramu v asembleru -pro labužníky
Tahle pasáž se týká toho, jak ladit program, ve kterém nejsou ladící informace. To je hodně pokročilá věc, která skýtá mnohá úskalí. Popravdě, tohle jsem já nikdy nepoužil a bohapustě jsem to opsal. Svým způsobem nevím, proč jsou potebřeba ladící informace na krokování programu v asembleru.Ale poradit si jde.
Nejdříve je potřeba zjistit, od které adresy se program spouští. V Gdb lze vstupní adresu zjistit příkazem info target, který kromě jiných údajů vypíše i vstupní adresu - entry point.
Je-li známa adresa, od které je program vykonáván, nastaví se na ni breakpoint a program se spustí. Nyní je možno program krokovat, nastavovat breakpointy, ale nefunguje příkaz disassemble. Ten vyžaduje ladící informace ( je-li možno v tomto případě příkaz disassemble zprovoznit, nevím o tom a uvítám případné připomínky).
Krokuje se příkazy si nebo ni. Málokdo však zná binární kód krokovaného programu, aniž by jej předtím viděl. Jak tedy zobrazit výpis v assembleru?
K tomuto účelu dobře poslouží příkaz x (eXamine).
x/3i $pc
pc je název registru čítače adresy (program counter) a příkaz x bude zkoumat obsah adresy v něm obsažené parametr i říká, že obsah zkoumané adresy bude zobrazen jako instrukce assembleru číslo 3 určuje, že budou zobrazeny 3 instrukce od adresy v pc
Příkaz x funguje jednorázově, pro zobrazování instrukce po každém kroku lze použít příkaz display.
disp /3i $pc
po každém zastavení programu jsou vypsány tři instrukce od adresy v pc
disp /5i $pc-2
bude vypisovat 2 instrukce před aktuální adresou, instrukci na aktuální adrese a 2 instrukce za ní.
Obsahy základních registrů vypíše příkaz info registers a obsahy všech registrů pak příkaz info all-registers. Jména registrů jsou závislá na platformě, Gdb však zavádí 4 jména, která by měla fungovat na všech platformách. Jsou to
| pc | program counter - v registru je uložena adresa právě vykonávané instrukce |
| sp | stack pointer - adresa v sp ukazuje na vrchol zásobníku |
| fp | frame pointer - obsahuje adresu aktuálního stack framu |
| ps | processor status |
Na registry se lze odkazovat jejich jménem jako na běžnou proměnnou. Před názvem však musí být uveden znak "$". Měnit obsahy registrů je možno příkazem
set $registr = hodnota
nebo příkazem print
$registr = hodnota
,který zároveň vytiskne novou hodnotu. Např. změnou hodnoty registru pc se skočí na jinou adresu, ale program je stále zastaven.
Proměnné
K proměnným v programu lze přistupovat přímo jejich jménem. Dereference se zapisuje jako v C pomocí znaku "*". Změnit jejich hodnotu lze příkazy print prom=hodnota a set var prom=hodnota. Pro různé účely je možno definovat nové proměnné v prostředí Gdb. To se provede příkazem set $prom=hodnota. Vlastní proměnné vypíše příkaz show convenience. Příklad použití vlastních proměnných:
Ukázka
(gdb) set $i = 0 (gdb) print pole[$i++]->prvni
Ukázka V jednom z předchozích odstavců jsem cosi povídal o výpisu paměti. použil jsem tam to, že jsem znal velikost pole intů. pokud bych jí chtěl zjistit, můžu požít příkaz
(gdb) set $velikost =sizeof(cisla)/4 (gdb) print $velikost $4 = 10
Zápis hodnoty na konkrétní adresu lze provést příkazem set {type}addr. Ve složených závorkách je uveden typ hodnoty (a tím i velikost). Typy jsou stejné jako v C.
Definování maker
V Gdb je možno definovat uživatelské příkazy včetně příkazů s argumenty. Slouží k tomu následující příkaz:
define prikaz
Počátek definice příkazu prikaz. Mohou následovat příkazy gdb, vždy jeden na řádek. Definici ukončuje řádka s příkazem end.
K argumentům příkazu lze přistupovat pomocí proměnných $arg0, $arg1, atd., kde $arg0 obsahuje hodnotu prvního argumentu. Je-li příkazu předáno méně argumentů, než je v definici použito, gdb vypíše chybu "Missing argument x in user function". V příkazu mohou být i podmínky:
if expr
Je-li splněna podmínka expr, vykonají se příkazy na následujících řádkách. Příkaz if může být následován řádkou s příkazem else. Seznam příkazů pro blok if [else] se ukončí řádkou s příkazem end.
until expr
Seznam příkazů za příkazem while, ukončený řádkou s příkazem end, se bude vykonávat, dokud výraz expr bude vyhodnocován jako pravdivý.
Jsou k dispozici i nekteré další kostrukce, jako printf, a echo.
Uživatelský příkaz může být dokumentován příkazem
document prikaz.
Příkaz už musí být definován. Text přiřazený příkazu je pak dostupný v helpu. Celé sady příkazů jdou načíst pomocí příkazu
source.
Prohlédnout příkazy, kterými je definován nějaký uživatelský příkaz, lze příkazem show user prikaz. Mimochodem tohle je jedna z věcí, ve které si myslím, že je GDB silnější než grafické ladící nástroje.
Ukázka
define vypis_cisla if ($arg0 == 1) print cisla else print cilsa end end
(gdb) vypis_cisla 1
$2 = {10, 12, 2, 4, 8, 7, 1, 20, 3, 25}
Ukázka session -odladění vzorového příkladu
To máte za domácí úkol, stejně jsem to už natáhl víc, než jsem chtěl :-)
Nástroje pro kontrolu dynamicky alokované paměti
Protože ne vždy víme, kolik místa budeme v programu potřebovat, je jazyk C obohacem o funkce malloc() a free() pro alokaci a dealokaci paměti za běhu programu. Bohužel, s dynamickou pamětí je problém, konkrétně jde o to, že
- program sáhne na paměť, kterou nemá alokovanou, tj. způsobí chybu segmentace
- program neuvolňuje paměť a sám se utopí ve množstí alokované paměti, na kterou nevede žádný pointer (popř. způsobí problém systému)
Obecně by mělo platit následující
- program nikdy nepřistoupí k paměti, kterou nemá alokovanou
- program nikdy nepřesáhne meze paměti, kterou má alokovanou
- počet volání malloc a free je vždy stejný
Co je smutné je fakt, že se na chyby v dynamicky alokované paměti špatně přichází Samozřejmě, že jsou postupy a knihovny, které se tento problém snaží řešit. Já tady popíšu následující tři.
MALLOC_CHECK_, aneb řešení ze standartní knihovny
MALLOC_CHECK_
je systémová proměnná, pokud ji nastavíme na 2, program se zastaví pokud
- dojde k zápisu (ne přístupu !!) bezprostředně před začátek alokované paměti
- dojde k dvojí dealokaci
Ukázka
Popisuje program aloktor, který se pokusí dvakrát dealokovat alokovanou paměť $ export MALLOC_CHECK_=2 $ ./alokator Aborted(core dumped)
mtrace
mtrace je výborný nástroj,ale má drobnou nevýhodu... program musí skončit normálně (tj. regulérním opuštěním funkce main), jinak tento nástroj nefunguje(nebo fungovat nemusí). Jde použít na
- detekci selhání dealokace alokované paměti
- detekci dealokace paměti, která nebyla alokována
Používá se násldujícím způsomem:
- Specifikujeme systémovou proměnnou
MALLOC_TRACE
- Do laděného kódu se vloží
#include <mcheck.h>
- Na začátku funkce main() se volá funkce mtrace
- No a ve specifikovaném souboru budou informace o chybných dealokacích
Ukázka
$export MALLOC_TRACE=mlog.log $ ./alokator2 $ cat mlog.log - 00000000000 Free 1 was never alloc'd alokator2.c:20 Memory not freed ---------------- Address Size Caller 0x08049d48 0xc at alokator2.c:15
knihovna electric fence
Tato knihovna zastaví program tam, kde dojde k přístupu mimo alokovanou paměť. Detekuje to následující věci
- Zápis a čtení před a za alokovanou paměť
- Zápis a čtení do paměti, která byla dealokována
- Alokaci paměti nulové velikosti
Pracuje vpodstatě tak, že do paměti nastřílí náhodnou špínu a program pak spadne hned a ne až jednou, za mnoho dní a nocí :-). Teda tohle se to traduje, ale ono to dělá ještě i něco navíc. Na každý kousek paměti se alokují alespoň dvě stránky paměti paměť kterou jsme opravdu chtěli se umístí do konce první stránky, a knihovna hlídá jestli nechceme psát někam jinám do těch stránek. Z toho ovšem plyne poměrně nepříjemná věc, že tahle kráska spotřebovává strašně moc paměti. Proto používat s mírou a pouze pro ladící účely. V každém případě, pokud uděláte něco z popsaných věcí tak to prosě spadne.
$./alokator3 Electric Fence 2.0.1 Copyright (C) 1987-1996 Bruce Perens. Segmentation fault
A kde to spadlo se můžeme podívat pomocí gdb Docela pěkně jde kombinovat s gdb přímo, viz ta pasáž o konfiguráku. Její použití spočívá v tom, že ji slinkujeme s programem
gcc -c -Wall -pedantic alokator3.o -o alokator3 -lefence
