GDB est\u00a0une commande de base pour tout d\u00e9veloppment en C\/C++\/Fortran. Il devrait donc \u00eatre sur votre syst\u00e8me. Si c’est le cas, passez cette section.<\/p>\n
\r\nyum install gdb\r\n<\/pre>\nPour l’installer sous Ubuntu:<\/p>\n
\r\napt-get install gdb\r\n<\/pre>\nUne fois install\u00e9 vous devriez pouvoir le lancer:<\/p>\n
\r\ngdb\r\n<\/pre>\nEt obtenir une sortie analogue \u00e0 celle-ci:<\/p>\n
\nGNU gdb (GDB) Red Hat Enterprise Linux 7.6.1-94.el7
\nCopyright (C) 2013 Free Software Foundation, Inc.
\nLicense GPLv3+: GNU GPL version 3 or later
\nThis is free software: you are free to change and redistribute it.
\nThere is NO WARRANTY, to the extent permitted by law. Type \u00ab\u00a0show copying\u00a0\u00bb
\nand \u00ab\u00a0show warranty\u00a0\u00bb for details.
\nThis GDB was configured as \u00ab\u00a0x86_64-redhat-linux-gnu\u00a0\u00bb.
\nFor bug reporting instructions, please see:
\nhttp:\/\/www.gnu.org\/software\/gdb\/bugs.
\n(gdb)\n<\/p><\/blockquote>\nLancer GDB<\/h1>\n
GDB se lance avec le programme cible en argument. Pour illutrer cela, consid\u00e9rons le programme erron\u00e9 suivant:<\/p>\n
\r\nint main(int argc, char *argv[])\r\n{\r\n\tint *a = NULL;\r\n\r\n\t*a = 9;\r\n\r\n\treturn 0;\r\n}\r\n<\/pre>\nCompilons le avec les symboles de d\u00e9bug (consid\u00e9rant qu’il s’appelle t.c) :<\/p>\n
\r\ngcc -g t.c -o test\r\n<\/pre>\nL’option \u00ab\u00a0-g\u00a0\u00bb , demande \u00e0 GCC d’ajouter des informations suppl\u00e9mentaires au binaire, en particulier,le binaire contiendra les informations permettant de faire correspondre une fonction \u00e0 ses sources. Il est indispensable d’ajouter cette option pour d\u00e9boguer dans de bonnes conditions. Dans le cas contraire, certaines informatiosn pourraient \u00eatre seulement partiellement visibles.<\/p>\n
Si nous lan\u00e7ons le programme:<\/p>\n
\r\n.\/test\r\n<\/pre>\nNous obtenons la sortie suivante:<\/p>\n
\n[1] 10446 segmentation fault .\/test\n<\/p><\/blockquote>\n
Cela s’iginifie que le programme a \u00e9t\u00e9 interrompu car il a fait un acc\u00e8s m\u00e9moire incorrect, provoquant une erreur se segmentation. La pluspart du temps, cela s’ignifie qu’il \u00e0 lu ou \u00e9crit \u00e0 une adresse incorrecte. Dans la majorit\u00e9 des cas impliquant ce type d’erreur, il faut utiliser un d\u00e9bogueur pour extraire l’\u00e9tat du programme menant \u00e0 cette erreur et donc pour la corriger. Pour langer avec GDB, il faut utiliser simplement la commande suivante:<\/p>\n
\r\ngdb .\/test\r\n<\/pre>\nNotez que si .\/test<\/b> prennait des arguments il faudrait utiliser :<\/p>\n\r\ngdb --args .\/test ARG1 ARG2\r\n<\/pre>\nDans le cas contraire les arguments ne seraient pas transmis au programme.<\/p>\n
Pour quitter GDB on peut soit utiliser la commande quit<\/b> dans l’invite GDB:<\/p>\n\r\n(gdb) quit\r\n<\/pre>\nOu bien de mani\u00e8re plus succinte faire CTRL+D (pour \u00e9mettre un EOF, end-of-file).<\/p>\n
Attacher GDB<\/h1>\n
Il est \u00e9galement possible de s’attacher \u00e0 un programme en cours d’\u00e9x\u00e9cution. Cela peut \u00eatre utile par exemple pour voir o\u00f9 le programme en est et pour diagnostiquer des inter-blocages. Dans cet exemple nous allons diagnostiquer un inter-blocage:<\/p>\n
\r\n\r\nint bar()\r\n{\r\n while(1){}\r\n}\r\n\r\nint main(int argc, char *argv[])\r\n{\r\n\tbar();\r\n\treturn 0;\r\n}\r\n<\/pre>\nIl est possible de voir que ce programme ne se terminera jamais. Compilons le:<\/p>\n
\r\ngcc -g t.c -o testddlk\r\n<\/pre>\nEt lan\u00e7ons le:<\/p>\n
\r\n.\/testddlk\r\n<\/pre>\nLe programme est comme pr\u00e9vu bloqu\u00e9. Maintenant comment le suivre dans GDB ? en particulier car nous ne l’avons pas lanc\u00e9 pr\u00e9fix\u00e9 par celui-ci.<\/p>\n
La premi\u00e8re \u00e9tape est de r\u00e9cup\u00e9rer le PID du programme cible. Le plus simple est de reposer sur la commande :<\/p>\n
\r\nps ux\r\n<\/pre>\nOn a par exemple la sortie suivante:<\/p>\n
\nUSER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
\njbbesna+ 13506 0.0 0.0 145020 2296 ? S 09:32 0:00 sshd: jbbesnard@pts\/0
\njbbesna+ 13507 0.0 0.0 145828 6940 pts\/0 Ss 09:32 0:00 -zsh
\njbbesna+ 13591 0.0 0.0 145020 2300 ? S 09:32 0:00 sshd: jbbesnard@pts\/1
\njbbesna+ 13592 0.0 0.0 142792 5796 pts\/1 Ss 09:32 0:00 -zsh
\njbbesna+ 13753 89.0 0.0 4156 344 pts\/0 R+ 09:34 0:03 .\/testddlk<\/b>
\njbbesna+ 13758 0.0 0.0 151056 1816 pts\/1 R+ 09:34 0:00 ps ux\n<\/p><\/blockquote>\n
On trouve alors facilement la commande .\/testddlk et son PID : 13753. On peut donc attacher<\/b> GDB \u00e0 ce programme:<\/p>\n\r\n# gdb PROG PID\r\n gdb .\/testddlk 13753\r\n<\/pre>\nUne approche alternative est de lancer GDB:<\/p>\n
\r\ngdb\r\n<\/pre>\nEt d’utiliser la commande \u00ab\u00a0attach PID\u00a0\u00bb dans l’invite de commande :<\/p>\n
\r\n(gdb) attach 13753\r\n<\/pre>\nDans les deux cas vous obtiendrez la sortie suivante :<\/p>\n
\nReading symbols from \/home\/jbbesnard\/gdb\/testddlk…done.
\nAttaching to program: \/home\/jbbesnard\/gdb\/.\/testddlk, process 13753
\nReading symbols from \/lib64\/libc.so.6…(no debugging symbols found)…done.
\nLoaded symbols for \/lib64\/libc.so.6
\nReading symbols from \/lib64\/ld-linux-x86-64.so.2…(no debugging symbols found)…done.
\nLoaded symbols for \/lib64\/ld-linux-x86-64.so.2
\nbar () at .\/t.c:3
\n3\t while(1){}
\nMissing separate debuginfos, use: debuginfo-install glibc-2.17-157.el7_3.1.x86_64\n<\/p><\/blockquote>\n
Notez que le programme cible est interrompu, et qu’il se troube bien \u00e0 la ligne du deadlock. Si vous quitez GDB (CTRL+D) le programme va reprendre son \u00e9x\u00e9cution normale. Une fois attach\u00e9 dans GDB il est possible de se d\u00e9tacher sans relancer GDB (si par exemple vous suivez de multiples processus).<\/p>\n
Pour ce faire on utilise la commande suivante dans l’invite de commande de GDB:<\/p>\n
\r\n(gdb) detach\r\n<\/pre>\nExplorer l’\u00e9tat d’un programme<\/h1>\n
Dans les exemples suivants nous allons consid\u00e9rer le code suivant:<\/p>\n
\r\n#include <omp.h>\r\n#include <stdio.h>\r\n\r\nint add( int a , int b )\r\n{\r\n\treturn a + b;\r\n}\r\n\r\nint mul(int a, int b)\r\n{\r\n\treturn a*b;\r\n}\r\n\r\nint foo( int a , int b )\r\n{\r\n\treturn add( a, b ) + mul( a , b );\r\n}\r\n\r\nint main(int argc, char *argv[])\r\n{\r\n\tint a, b;\r\n\ta = 8;\r\n\tb = 9;\r\n\t#pragma omp parallel\r\n\t{\r\n\t\tprintf("foo : %d\\n", foo( a , b ) );\r\n\t}\r\n\r\n\treturn 0;\r\n}\r\n<\/pre>\nCe code est un code OpenMP, si vous n’\u00eates pas trop familier avec ce mod\u00e8le de programmation, sachez juste que dans la section avec des acolades de multiples threads seront cr\u00e9\u00e9s. Cela s’ignifie que plusieurs fils d’\u00e9x\u00e9cution vont traiter le code du prinf et donc \u00e9crire sur la sortie standard.<\/p>\n
Pour compiler ce code, nous mettons les symboles de d\u00e9bug -g<\/b> et ajoutons le support OpenMP -fopenmp<\/b>:<\/p>\n\r\ngcc -g -fopenmp p.c -o par\r\n<\/pre>\nPour v\u00e9rifier nos dires lan\u00e7ons ce code:<\/p>\n
\nfoo : 89
\nfoo : 89
\nfoo : 89
\nfoo : 89
\nfoo : 89
\nfoo : 89
\nfoo : 89
\nfoo : 89\n<\/p><\/blockquote>\n
On retrouve huit fois la sortie, cela correspond aux huit coeurs de notre machine de test.<\/p>\n
Les points d’arr\u00eat<\/h2>\n
Notez avant toute chose que GDB s’arr\u00eate si le programme rencontre un signal (par exemple une erreur de segmentation). Il est donc possible de l’\u00e9x\u00e9cuter directement pour se rendre au lieu de l’erreur sans avoir recours aux breakpoints.<\/p>\n
Maintenant, consid\u00e9rons que nous voulions explorer l’\u00e9tat du programme dans la fonction add. Pour ce faire, il faut placer un breakpoint<\/b> ou point d’arr\u00eat. Il forcera le programme a s’interrompre quant il entrera dans la fonction add.<\/p>\n
On lance le programme avec GDB:<\/p>\n
\r\ngdb .\/par\r\n<\/pre>\nOn place alors un point d’arr\u00eat sur add :<\/p>\n
\r\n(gdb) break add\r\nBreakpoint 1 at 0x4006c7: file p.c, line 6.\r\n<\/pre>\nOn remarque alors que GDB confirme la position de ce point d’arr\u00eat, indiquant m\u00eame la ligne source.<\/p>\n
Il est maintenant temps de lancer le programme avec la commande run<\/b> aussi abr\u00e9geable en r<\/b><\/p>\n\r\n(gdb) run\r\n<\/pre>\nGDB comme attendu va alors arr\u00eater le programme dans add<\/b>:<\/p>\n\n[Switching to Thread 0x7ffff45d3700 (LWP 14196)]
\nBreakpoint 1, add (a=8, b=9) at p.c:6
\n6\t\treturn a + b;
\n(gdb)\n<\/p><\/blockquote>\n
Le programme cible est alors interrompu au point indiqu\u00e9, p.c \u00e0 la ligne 6 (not\u00e9 p.c:6) dans la fonction add. GDB affiche \u00e9galement la ligne source.<\/p>\n
Il est possible de lister les breakpoint actif avec la commande suivante:<\/p>\n
\r\n(gdb) info breakpoint\r\nNum Type Disp Enb Address What\r\n1 breakpoint keep y 0x00000000004006c7 in add at p.c:6\r\n\tbreakpoint already hit 1 time\r\n<\/pre>\nNoter que cette commande peut \u00eatre racourcie comme de nombreuse commandes GDB:<\/p>\n
\r\n(gdb) i b\r\n<\/pre>\nOn peut supprimer un breakpoint avec delete<\/b>:<\/p>\n\r\n(gdb) delete 1\r\n(gdb) i b\r\nNo breakpoints or watchpoints.\r\n<\/pre>\nOn peut temporairement d\u00e9sactiver un breakpoint (remarquer le changement de Enb) :<\/p>\n
\r\n(gdb) info b\r\nNum Type Disp Enb Address What\r\n3 breakpoint keep y 0x00000000004006c7 in add at p.c:6\r\n(gdb) disable 3\r\n(gdb) info b\r\nNum Type Disp Enb Address What\r\n3 breakpoint keep n 0x00000000004006c7 in add at p.c:6\r\n<\/pre>\nEt par sym\u00e9trie, le r\u00e9activer:<\/p>\n
\r\n(gdb) enable 3\r\n(gdb) i b\r\nNum Type Disp Enb Address What\r\n3 breakpoint keep y 0x00000000004006c7 in add at p.c:6\r\n<\/pre>\nEnfin, disable<\/b> et enable<\/b> sans param\u00e8tre d\u00e9sactivent\/activent tout les points d’arr\u00eat.<\/p>\n
Enfin on peut continuer l’\u00e9x\u00e9cution normale du programme avec :<\/p>\n
\r\n(gdb) continue\r\nContinuing.\r\n<\/pre>\n\u00c0 partir de maintenant, utilisez:<\/p>\n
\r\n(gdb) c\r\nContinuing.\r\n<\/pre>\nLa pile d’appel<\/h2>\n
Une fois arr\u00eat\u00e9s dans add, il est possible d’afficher la pile d’appel (les fonction appel\u00e9es) qui nous ont men\u00e9es \u00e0 cet appel \u00e0 add. C’est l’une des command les plus importante pour le d\u00e9bogage.<\/p>\n
G\u00e9n\u00e9rons alors la pile d’appel:<\/p>\n
\r\n(gdb) backtrace\r\n#0 add (a=8, b=9) at p.c:6\r\n#1 0x0000000000400702 in foo (a=8, b=9) at p.c:18\r\n#2 0x00000000004007a1 in main._omp_fn.0 () at p.c:30\r\n#3 0x00007ffff7bcd435 in ?? () from \/lib64\/libgomp.so.1\r\n#4 0x00007ffff79a2dc5 in start_thread () from \/lib64\/libpthread.so.0\r\n#5 0x00007ffff76d173d in clone () from \/lib64\/libc.so.6\r\n<\/pre>\n\u00c0 l’avenir utilisez la version courte de cet appel:<\/p>\n
\r\n(gdb) bt\r\n<\/pre>\nOn observe que add a \u00e9t\u00e9 appel\u00e9 de la fonction foo qui a elle m\u00eame \u00e9t\u00e9 appel\u00e9e depuis le main (avec la complexit\u00e9 suppl\u00e9mentaire d’un contexte OpenMP).<\/p>\n
On retrouve pour chaque fonction de la pile d’appel les informations suivantes:<\/p>\n
\n- #1 : Le num\u00e9ro de frame<\/li>\n
- 0x0000000000400702 : Addresse du pointeur programme<\/li>\n
- foo : le nom de la fonction<\/li>\n
- (a=8, b=9) : les param\u00e8tres de la fonction<\/li>\n
- at p.c:18 : la position de la fonction dans le code<\/li>\n
- from \/lib64\/libpthread.so.0 : la biblioth\u00e8que contenant le symbole (quand applicable)<\/li>\n<\/ul>\n
La frame<\/h2>\n
Une frame est une instance d’appel de fonction dans la pile d’appel, est est d\u00e9crite par un identifiant dans le backtrace. Par exmple foo dans l’exemple pr\u00e9c\u00e9dent est \u00e0 la frame #1. Il est possible de monter dans la pile d’appel avec la commande suivante:<\/p>\n
\r\n(gdb) up\r\n#1 0x0000000000400702 in foo (a=8, b=9) at p.c:18\r\n18\t\treturn add( a, b ) + mul( a , b );\r\n<\/pre>\nEt bien s\u00fbr de descendre:<\/p>\n
\r\n(gdb) down\r\n#0 add (a=8, b=9) at p.c:6\r\n6\t\treturn a + b;\r\n<\/pre>\nCes commandes \u00e9tant racourcissable en up<\/b> et do<\/b>.<\/p>\n
Il est \u00e9galement possible de se rendre directement \u00e0 une frame avec son num\u00e9ro:<\/p>\n
\r\n(gdb) frame 2\r\n#2 0x00000000004007a1 in main._omp_fn.0 () at p.c:30\r\n30\t\t\tprintf("foo : %d\\n", foo( a , b ) );\r\n<\/pre>\n\u00c0 partir de maintenant vous utiliserez fr<\/b> en lieu et place de frame<\/b><\/p>\n
Il est possible de r\u00e9cup\u00e9rer les informations de la frame courante avec :<\/p>\n
\r\n(gdb) info frame\r\nStack level 0, frame at 0x7ffff45d2e20:\r\n rip = 0x4006cf in add (p.c:7); saved rip 0x400702\r\n called by frame at 0x7ffff45d2e40\r\n source language c.\r\n Arglist at 0x7ffff45d2e10, args: a=8, b=9\r\n Locals at 0x7ffff45d2e10, Previous frame's sp is 0x7ffff45d2e20\r\n Saved registers:\r\n rbp at 0x7ffff45d2e10, rip at 0x7ffff45d2e18\r\n<\/pre>\nOn trouve dans cette sortie de nombreuses informations, avec par exemple les arguments de la fonction. Notez que l’on peut lister les arguments avec :<\/p>\n
\r\n(gdb) info args\r\na = 8\r\nb = 9\r\n<\/pre>\nEt l’ensemble des variables locales avec:<\/p>\n
\r\n(gdb) fr 2\r\n#2 0x00000000004007a1 in main._omp_fn.0 () at p.c:30\r\n30\t\t\tprintf("foo : %d\\n", foo( a , b ) );\r\n(gdb) info locals\r\na = 8\r\nb = 9\r\n<\/pre>\nFaire avancer le programme<\/h2>\n
Quand vous lancez GDB, il faut faire \u00ab\u00a0run\u00a0\u00bb (ou \u00ab\u00a0r\u00a0\u00bb) pour que le programme commence. Si vous ne pla\u00e7ez aucun breakpoint, le programme va se terminer. Faire \u00ab\u00a0run\u00a0\u00bb \u00e0 nouveau le lancera encore une fois. Ensuite, quand vous souhaitez quitter un breakpoint, faites \u00ab\u00a0continues\u00a0\u00bb ou \u00ab\u00a0c\u00a0\u00bb. Le programme continue alors son \u00e9x\u00e9cution.<\/p>\n
Il est \u00e9galement possible d’avancer ligne de code par ligne de code avec \u00ab\u00a0step\u00a0\u00bb ou \u00ab\u00a0s\u00a0\u00bb, et enfin d’une seule instruction avec \u00ab\u00a0si\u00a0\u00bb.<\/p>\n
Afficher les sources<\/h2>\n
Dans GDB il est possible d’afficher les lignes sources proche du point d’arr\u00eat. Pour cela on utilise:<\/p>\n
\r\n(gdb) list\r\n1\t#include <omp.h>\r\n2\t#include <stdio.h>\r\n3\r\n4\tint add( int a , int b )\r\n5\t{\r\n6\t\treturn a + b;\r\n7\t}\r\n8\r\n9\r\n10\tint mul(int a, int b)\r\n<\/pre>\nChaque nouvel appel \u00e0 list<\/b> affichera la suite du code.<\/p>\n
Pour \u00ab\u00a0remonter\u00a0\u00bb utilisez:<\/p>\n
\r\n(gdb) list -\r\n<\/pre>\nInspecter les threads<\/h2>\n
Notre petit exemple cr\u00e9e de multiple threads, il y a donc plusieurs instance de pile dans le programme que nous avons d\u00e9bogu\u00e9 jusqu’\u00e0 maintenant. Les commandes pr\u00e9c\u00e9dentes se sont donc appliqu\u00e9es \u00e0 un seul thread (flot d’\u00e9x\u00e9cution), le choix du thread \u00e9tant celui du premier entrant dans le breakpoint.<\/p>\n
Il est possible de lister les threads avec:<\/p>\n
\r\n(gdb) info thread\r\n Id Target Id Frame\r\n 8 Thread 0x7ffff45d3700 (LWP 16038) "par" add (a=8, b=9) at p.c:6\r\n* 7 Thread 0x7ffff4dd4700 (LWP 16037) "par" add (a=8, b=9) at p.c:6\r\n 6 Thread 0x7ffff55d5700 (LWP 16036) "par" add (a=8, b=9) at p.c:6\r\n 5 Thread 0x7ffff5dd6700 (LWP 16035) "par" add (a=8, b=9) at p.c:6\r\n 4 Thread 0x7ffff65d7700 (LWP 16034) "par" add (a=8, b=9) at p.c:6\r\n 3 Thread 0x7ffff6dd8700 (LWP 16033) "par" add (a=8, b=9) at p.c:6\r\n 2 Thread 0x7ffff75d9700 (LWP 16032) "par" add (a=8, b=9) at p.c:6\r\n 1 Thread 0x7ffff7fe27c0 (LWP 16031) "par" add (a=8, b=9) at p.c:6\r\n<\/pre>\nNotez comment le thread actuellement s\u00e9lectionn\u00e9 est indiqu\u00e9 par une ast\u00e9risque (*). De plus il est important d’observer que la fonction courante, ses arguments et sa position sont indiqu\u00e9e dans cet appel. Cela le rend tr\u00e8s pratique car il permet de voir en une commande la situation de touts les threads. Ici, ils sont tous dans la fonction add.<\/p>\n
Tout comme les frames, il est possible de changer de thread :<\/p>\n
\r\n(gdb) thread 1\r\n[Switching to thread 1 (Thread 0x7ffff7fe27c0 (LWP 16031))]\r\n#0 add (a=8, b=9) at p.c:6\r\n6\t\treturn a + b;\r\n<\/pre>\nVous pouvez \u00e9galement utiliser la syntaxe courte thr<\/b>. Une fois ce changement effectu\u00e9, vous pouvez utilisez l’ensemble des commandes pour inspecter son contexte.<\/p>\n
Il est possible de nommer les threads en utilisant :<\/p>\n
\r\n(gdb) thread name BUG\r\n(gdb) info thread\r\n Id Target Id Frame\r\n 8 Thread 0x7ffff45d3700 (LWP 30206) "par" add (a=8, b=9) at p.c:6\r\n 7 Thread 0x7ffff4dd4700 (LWP 30205) "par" add (a=8, b=9) at p.c:6\r\n 6 Thread 0x7ffff55d5700 (LWP 30204) "par" add (a=8, b=9) at p.c:6\r\n* 5 Thread 0x7ffff5dd6700 (LWP 30203) "BUG" add (a=8, b=9) at p.c:6\r\n 4 Thread 0x7ffff65d7700 (LWP 30202) "par" add (a=8, b=9) at p.c:6\r\n 3 Thread 0x7ffff6dd8700 (LWP 30201) "par" add (a=8, b=9) at p.c:6\r\n 2 Thread 0x7ffff75d9700 (LWP 30200) "par" add (a=8, b=9) at p.c:6\r\n 1 Thread 0x7ffff7fe27c0 (LWP 30196) "par" add (a=8, b=9) at p.c:6\r\n<\/pre>\nCe qui est tr\u00e8s pratique pour s’y retrouver parfois. Enfin il est possible d’appliquer une commande \u00e0 plusieurs threads \u00e0 la fois :<\/p>\n
\r\n(gdb) thread apply 1-4 print a\r\n\r\nThread 1 (Thread 0x7ffff7fe27c0 (LWP 30196)):\r\n$3 = 8\r\n\r\nThread 2 (Thread 0x7ffff75d9700 (LWP 30200)):\r\n$4 = 8\r\n\r\nThread 3 (Thread 0x7ffff6dd8700 (LWP 30201)):\r\n$5 = 8\r\n\r\nThread 4 (Thread 0x7ffff65d7700 (LWP 30202)):\r\n$6 = 8\r\n<\/pre>\nDe plus passer \u00ab\u00a0all\u00a0\u00bb permet d’invoquer une commande sur tous les threads, par exemple :<\/p>\n
\r\n(gdb) thread apply all bt\r\n<\/pre>\nInspecter les variables<\/h2>\n
A tout moment dans GDB il est possible d’explorer le contenu de la m\u00e9moire. Pour cela, on utilise g\u00e9n\u00e9ralement la fonction print. Cette fonction peut s’utilisez tr\u00e8s simplement:<\/p>\n
\r\n(gdb) print a\r\n$1 = 8\r\n<\/pre>\n\u00c0 partir de maintenant utilisez la version courte p<\/b>. Print peut effectuer de nombreuses manipulation sur la sortie, de plus les variables pass\u00e9es en param\u00e8tre peuvent \u00eatre alt\u00e9r\u00e9es tout comme en C. Pour illustrer cela trouvons l’addresse de a:<\/p>\n\r\n(gdb) print &a\r\n$2 = (int *) 0x7fffffffe11c\r\n<\/pre>\nEt maintenant affichons le contenu \u00e0 cette addresse comme un int:<\/p>\n
\r\n(gdb) p *((int*)0x7fffffffe11c)\r\n$3 = 8\r\n<\/pre>\nIl est de plus tout \u00e0 fait possible de faire de l’arithm\u00e9tique de pointeur. Par exemple en consid\u00e9rant la mani\u00e8re dont les variables sont rang\u00e9es sur la pile, b est stock\u00e9 juste avant a, v\u00e9rifions le:<\/p>\n
\r\np ((int*)0x7fffffffe11c)[-1]\r\n$10 = 9\r\n<\/pre>\nOn a bien &b = &a – 4 , avec 4 la taille en octed d’un entier:<\/p>\n
\r\n(gdb) p &b\r\n$11 = (int *) 0x7fffffffe118\r\n<\/pre>\nSi nous consid\u00e9rons un code trivial avec un tableau:<\/p>\n
\r\n#include <stdio.h>\r\n\r\nint main(int argc, char *argv[])\r\n{\r\n\tint *a = NULL;\r\n\tint array[4] = {1,2,3,4};\r\n\t*a = 9;\r\n\treturn 0;\r\n}\r\n<\/pre>\nOn peut afficher le contenu de ce tableau dans GDB:<\/p>\n
Directement:<\/p>\n
\r\n(gdb) p array\r\n$1 = {1, 2, 3, 4}\r\n<\/pre>\nEn utilisant l’op\u00e9rateur de longueur:<\/p>\n
\r\n(gdb) p array[0]@4\r\n$2 = {1, 2, 3, 4}\r\n<\/pre>\nOu bien via un cast:<\/p>\n
\r\n(gdb) p *((int[4]*) &array[0])\r\n$9 = {1, 2, 3, 4}\r\n<\/pre>\nIl y a \u00e9galement des modifieurs de format, par exemple \u00ab\u00a0x\u00a0\u00bb pour hexad\u00e9cimal (voir ici<\/a> pour la liste):<\/p>\n\r\n(gdb) p\/x array[0]@4\r\n$7 = {0x1, 0x2, 0x3, 0x4}\r\n<\/pre>\nInspecter la m\u00e9moire<\/h2>\n
En reprenant notre exemple pr\u00e9c\u00e9dent, il est possible d’explorer la m\u00e9moire, par exemple pour afficher la m\u00e9moire \u00e0 l’endroit du tableau sur 4 entiers :<\/p>\n
\r\n(gdb) x\/4x &array[0]\r\n0x7fffffffe170:\t0x00000001\t0x00000002\t0x00000003\t0x00000004\r\n<\/pre>\nLes arguments de format \u00e9tant pris en compte:<\/p>\n
\r\n(gdb) x\/4d &array[0]\r\n0x7fffffffe170:\t1\t2\t3\t4\r\n<\/pre>\nPar d\u00e9faut, l’offset est de 4 octets, un entier, si vous voullez changer pour un byte tout en affichant maintenant 16 bytes (ou 4 * 4 entiers de 4 bytes) :<\/p>\n
\r\n(gdb) x\/16db &array[0]\r\n0x7fffffffe170:\t1\t0\t0\t0\t2\t0\t0\t0\r\n0x7fffffffe178:\t3\t0\t0\t0\t4\t0\t0\t0\r\n<\/pre>\nVoir ici<\/a> pour les diff\u00e9rentes options.<\/p>\nConclusion<\/h1>\n
Dans ce tutorial vous avez apris \u00e0 utliser GDB, \u00e0 le lancer ou bien \u00e0 vous attacher au processus cible. Ensuite, nous avons couvert les diff\u00e9rentes commandes de base. Dans un tuturial plus avanc\u00e9 nous couvrirons plus en d\u00e9tails les watchpoints et la possibilit\u00e9 de placer des commandes sur les breakpoints.<\/p>\n","protected":false},"excerpt":{"rendered":"
Dans cet article nous allons pr\u00e9senter l’utilisation basique du d\u00e9bogueur GDB. Nous commencerons par illustrer les diff\u00e9rents modes de lancement avant de pr\u00e9senter les diff\u00e9rentes commandes de base. \u00c0 la fin de ce tutoriel vous saurez: Lancer GDB sur votre programme Vous attacher \u00e0 un programme en cours d’\u00e9x\u00e9cution Explorer l’\u00e9tat d’un programme via l’invite […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[27],"tags":[30,29,31],"_links":{"self":[{"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/posts\/181"}],"collection":[{"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=181"}],"version-history":[{"count":38,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/posts\/181\/revisions"}],"predecessor-version":[{"id":251,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/posts\/181\/revisions\/251"}],"wp:attachment":[{"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=181"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=181"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=181"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}