آموزش GDB - قسمت ۱

سلام!

توی قسمت ۰، با چند تا دستور ابتدایی gdb کمی آشنا شدیم. حالا توی این بخش، چند تا دستور جدید یاد می‌گیریم! این دفعه قسمت بزرگی از هدفمون اینه که بتونیم با توابعی که صدا زده می‌شن هم کلنجار بریم! با درس‌های قسمت قبل، همچین کاری غیرممکن یا سخت بود. D:

درس منفی یکم: چند تا نکته‌ی کوچولو

اکثر وقت‌ها لازم نیست که ما شکل کامل دستوری که می‌خوایم رو تایپ کنیم. خیلی وقت‌ها تایپ کردن یه پیشوند از اون دستور که به صورت یکتا مشخّصش کنه یا عبارات مخفّفی که شناخته شدن، کار همون دستورات رو برامون انجام می‌دن. برای مثال، استفاده از b به جای break و یا استفاده از bt به جای backtrace.

خب حالا برای امروز، با این کد(code01.c) قراره کار کنیم:

#include <assert.h>

int fib(int n)
{
    assert(n >= 5); 
    if (n <= 1)
        return n;
    int x = fib(n - 1); 
    int y = fib(n - 2); 
    return x + y;
}

int main()
{
    fib(10);
    return 0;
}

همون طور که از ظاهر کد برمی‌آد، این کد قراره تابع فیبوناچی رو برامون محاسبه کنه. تنها نکته‌ش اینه که وقتی توی روند بازگشتی تابع fib، تابع به ازای nهای کم‌تر از ۵ صدا زده بشه، مقدار ورودی assert برابر با false می‌شه و برنامه به نوعی کرش می‌کنه.

برای کامپایلش هم مثل قسمت قبل:

gcc -g code01.c -o exec01

درس صفرم: file

خب قبلا برای دیباگ کردن همچین برنامه‌ای توی ترمینال می‌نوشتیم gdb exec01. الآن هم این کار رو می‌تونیم بکنیم. یکی از روش‌های دیگه، اینه که توی ترمینال فقط دستور gdb رو اجرا کنیم، بدون هیچ آرگومانی. در این صورت وارد فضای gdb می‌شیم و بعدش با دستور file، می‌تونیم مشخّص کنیم که قصدمون دیباگ کردن چه برنامه‌ای هست:

(gdb) file exec01 
Reading symbols from exec01...done.
(gdb)

حالا به راحتی برنامه رو با run اجرا می‌کنیم و می‌بینیم که:

(gdb) run
Starting program: /home/rakeb/tmp/exec01 
exec01: code01.c:5: fib: Assertion `n >= 5' failed.

Program received signal SIGABRT, Aborted.
__GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
51	../sysdeps/unix/sysv/linux/raise.c: No such file or directory.
(gdb)

که به زبون آدمی‌زادی می‌گه آقا این برنامه‌ی شما توی یه Assertion که شرطش n >= 5 بوده فِیل شده و بعد از اون، سیگنال SIGABRT برای برنامه فرستاده شده.

الآن برنامه‌مون هنوز خارج نشده! رفتار gdb با سیگنال‌هایی که مربوط به یه اروری می‌شن، مثل رفتارش با breakpointهاست! چون ممکنه برنامه نویس نیاز داشته باشه تا حول اون وضعیتی که منجر به کرش کردن شده، یه خرده چرخ بزنه و اطّلاعات به دست بیاره.

به هر حال، می‌تونیم با دستور next یا kill(درس نیمم؟!) به اجرای برنامه خاتمه بدیم. ولی فعلا این کار رو نمی‌کنیم تا با backtrace آشنا بشیم.

درس یکم: backtrace

اگر با پایتون کار کرده باشید، می‌دونید که وقتی به یه ارور می‌خوره و کرش می‌کنه، کل روندی که توابع هم دیگه رو صدا کردن تا به اون نقطه‌ی ایجاد خطا برسن رو چاپ می‌کنه براتون. اوّلش هم همچین چیزی می‌نویسه:

Traceback (most recent call last):

خب این اطّلاعات به دیباگ برنامه خیلی کمک می‌کنه. توی gdb هم همچین چیزی داریم. بلافاصله بعد از کرش کردن برنامه‌مون اگر دستور backtrace یا bt رو وارد کنیم، می‌بینیم که روند صدا شدن توابع به ترتیب از main تا این نقطه‌ای که برنامه کرش کرده رو برامون می‌نویسه:

(gdb) backtrace 
#0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
#1  0x00007ffff7a24801 in __GI_abort () at abort.c:79
#2  0x00007ffff7a1439a in __assert_fail_base (fmt=0x7ffff7b9b7d8 &quot%s%s%s:%u: %s%sAssertion `%s' failed.\n%n&quot, assertion=assertion@entry=0x55555555475d &quotn >= 5&quot, file=file@entry=0x555555554754 &quotcode01.c&quot, line=line@entry=5, function=function@entry=0x555555554764 <__PRETTY_FUNCTION__.1809> &quotfib&quot) at assert.c:92
#3  0x00007ffff7a14412 in __GI___assert_fail (assertion=0x55555555475d &quotn >= 5&quot, file=0x555555554754 &quotcode01.c&quot, line=5, function=0x555555554764 <__PRETTY_FUNCTION__.1809> &quotfib&quot) at assert.c:101
#4  0x000055555555467a in fib (n=4) at code01.c:5
#5  0x0000555555554692 in fib (n=5) at code01.c:8
#6  0x0000555555554692 in fib (n=6) at code01.c:8
#7  0x0000555555554692 in fib (n=7) at code01.c:8
#8  0x0000555555554692 in fib (n=8) at code01.c:8
#9  0x0000555555554692 in fib (n=9) at code01.c:8
#10 0x0000555555554692 in fib (n=10) at code01.c:8
#11 0x00005555555546bd in main () at code01.c:15
(gdb)

از پایین لیست به سمت بالای لیست، مسیر رسیدن از main به عامل کرش رو می‌تونیم ببینیم. واضحه که خطوط ۴ تا ۱۱ مربوط به برنامه‌ی شما هستن و خطوط ۰ تا ۳ توسّط تابع assert فراخوانی شدن. حالا با دستور kill برنامه رو می‌بندیم تا یه بار دیگه اجراش کنیم.

درس دوم: break if

حالا می‌خوایم یه breakpoint روی نقطه‌ی شروع تابع fib قرار بدیم تا وقتی که با n=5 صدا زده شد، روند اجرای برنامه رو دنبال کنیم. یک راهش اینه که خیلی ساده بنویسیم:

break fib

با این کار برنامه دقیقا لحظه‌ای که می‌خواد وارد این تابع بشه، متوقّف می‌شه و ما می‌تونیم با استفاده از این دستور و دستور continue اون قدر ادامه بدیم تا به n=5 برسیم. امّا راه ساده‌تری که وجود داره، استفاده از breakpointهای شرطیه. خیلی ساده می‌نویسیم:

(gdb) break fib if n == 5
Breakpoint 1 at 0x555555554655: file code01.c, line 5.
(gdb) run
Starting program: /home/rakeb/tmp/exec01 

Breakpoint 1, fib (n=5) at code01.c:5
5	    assert(n >= 5);
(gdb)

می‌بینید؟ دقیقا پشت اوّلین دستور از تابع وقتی که ورودی‌ش n=5 هست برنامه متوقّف شده. این جا هم می‌تونیم دستور bt رو بزنیم تا روند صدا شدن توابع رو ببینیم.

(gdb) bt
#0  fib (n=5) at code01.c:5
#1  0x0000555555554692 in fib (n=6) at code01.c:8
#2  0x0000555555554692 in fib (n=7) at code01.c:8
#3  0x0000555555554692 in fib (n=8) at code01.c:8
#4  0x0000555555554692 in fib (n=9) at code01.c:8
#5  0x0000555555554692 in fib (n=10) at code01.c:8
#6  0x00005555555546bd in main () at code01.c:15
(gdb)

خب حالا فرض کنید می‌خوایم قبل از ادامه‌ی برنامه، یه مقدار پرسه بزنیم توی این توابع و مقدار بعضی متغیّرها رو با دستور print نگاه کنیم! خب اگر این متغیّرها توی همین تابع فعلی باشن که اوکیه، ولی اگر توی فریم توابع بالادستی باشن چی؟ واضحه که همین طوری نمی‌تونیم مقدار n به ازای فراخوانی تابع مربوط به خط #3 رو نگاه کنیم! (حالا این جا n ورودی تابع هست و بدیهیه مقدارش چنده. امّا تو موارد مختلف، به جای این n می‌شه هر متغیّر لوکالی مد نظرمون باشه که مقدارش توی backtrace قابل مشاهده نباشه.

درس سوم: up/down

مفهوم این ۲ تا دستور خیلی ساده هست! با دستور up، می‌رید توی تابعی که تابع فعلی رو صدا زده. یعنی اگر توی تابع مربوط به خط iام از خروجی backtrace باشید، منتقل می‌شید به خط i+1. دستور down هم خلاف این کار رو می‌کنه و منتقل می‌شید به خط i-1! دقّت کنید که این منتقل شدن، هیچ تاثیری توی روند اجرای برنامه نداره. صرفا شما به صورت مجازی به اون جا منتقل می‌شید تا بتونید مقدار توابع رو نگاه کنید و تغییر بدید.

لازم به ذکره که این ۲ تا دستور، می‌تونن یه آرگومان اختیاری هم بگیرن که بفهمن به جای یک لایه، چند لایه برن بالا یا پایین. مثلا دستور up 5 شما رو منتقل می‌کنه به خط i + 5.

(gdb) up
#1  0x0000555555554692 in fib (n=6) at code01.c:8
8	    int x = fib(n - 1);
(gdb) print n
$1 = 6
(gdb) up 2
#3  0x0000555555554692 in fib (n=8) at code01.c:8
8	    int x = fib(n - 1);
(gdb) print n
$2 = 8
(gdb) down 
#2  0x0000555555554692 in fib (n=7) at code01.c:8
8	    int x = fib(n - 1);
(gdb) down
#1  0x0000555555554692 in fib (n=6) at code01.c:8
8	    int x = fib(n - 1);
(gdb) down
#0  fib (n=5) at code01.c:5
5	    assert(n >= 5);
(gdb) down
Bottom (innermost) frame selected; you cannot go down.
(gdb)

حالا می‌خوایم با یه روش کاملا احمقانه، کاری کنیم که برنامه‌مون وقتی n<=4 هست، به خط assert نرسه. برای این کار می‌خوایم با یه روش مشابه، یه breakpoint روی ورودی تابع fib به ازای زمان‌هایی که n<=4 هست بذاریم و توی این حالات، قبل از این که روند اجرای برنامه به assert برسه، خودمون دستی مقدار واقعی fib(n) رو return کنیم!

درس چهارم: info breakpoints

با این دستور می‌تونیم اطّلاعات breakpointهایی که توی برنامه‌مون وجود دارن رو ببینیم! در مورد همین مثال:

(gdb) info breakpoints
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000555555554655 in fib at code01.c:5
	stop only if n == 5
	breakpoint already hit 1 time
(gdb)

همون طور که می‌بینید، اطّلاعات مختلفی رو در مورد همون یه breakpoint که توی برنامه داشتیم چاپ کرده. خصوصیتی که در ادامه باهاش کار داریم، Enb یا Enabled هست.

لازم به ذکره اگر breakpointهای بیشتری هم وجود داشته باشن، توی این لیست با Numهای مختلف نشون داده می‌شن.

درس پنجم: enable/disable/remove breakpoints

ما می‌تونیم breakpointها رو غیرفعّال کنیم و یا پاکشون کنیم! برای غیر فعّال کردنشون کافیه از دستور زیر استفاده کنیم:

(gdb) disable breakpoints 1

که عدد ۱ در انتهای دستور، نشان‌دهنده‌ی Num مربوط به breakpointی هستش که می‌خوایم غیرفعّالش کنیم.

به طریق مشابه با استفاده از دستور enable به جای disable می‌تونیم یک breakpoint رو فعّال کنیم و با استفاده از delete به جای disable می‌تونیم اون breakpoint رو پاک کنیم. تغییراتی که این دستورات اعمال می‌کنن رو به راحتی با دستور info breakpoints می‌تونیم مشاهده کنیم.

حالا برای این که اون روش احمقانه مربوط به جلوگیری از کرش کردن برنامه رو پیاده‌سازی کنیم، کافیه اوّل دستورات زیر رو اجرا کنیم:

(gdb) break fib if n <= 4
Breakpoint 2 at 0x555555554655: file code01.c, line 5.
(gdb) run
Starting program: /home/rakeb/tmp/exec01 

Breakpoint 2, fib (n=4) at code01.c:5
5	    assert(n >= 5);
(gdb)

درس ششم: return

خب می‌دونیم که خروجی fib به ازای n=4 باید برابر با ۳ و به ازای n=3 باید برابر با ۲ باشه. برای همین کافیه هر وقت breakpointمون به fib(3) رسید از دستور return 2 و هر وقت به fib(4) رسید از دستور return 3 استفاده کنیم.

البته تابع fib(3) و fib(4) دفعات زیادی صدا خواهد شد و ما در نهایت پیر می‌شیم تا اون دستورات رو اجرا کنیم! این جا صرفا می‌خواستم بگم از لحاظ تئوری این کار ممکنه. :)) اگر خیلی مُصر هستید که این کار رو تجربه کنید، می‌تونید توی برنامه‌ی code01.c به جای فراخوانی fib(10)، تابع fib رو به ازای یک n کوچک‌تر فراخوانی کنید و یا موقعی که breakpoint می‌ذارید، به جای قرار دادن n<=4 از یه عدد بزرگتر استفاده کنید تا دفعات کم‌تری به اون breakpoint برسیم.

درس هفتم: list

حالا که تا این جای کار اومدیم، بیاید با چند تا دستور دیگه هم آشنا بشیم! ولی قبل از هر چیز، خط مربوط به assert رو از برنامه پاک کنید و برنامه رو مجدّدا اجرا کنید. مثل حالت قبل، یه breakpoint روی تابع fib به ازای حالاتی که n=5 هست می‌ذاریم!

(gdb) break fib if n == 5
Breakpoint 1 at 0x605: file code01.c, line 5.
(gdb) run
Starting program: /home/rakeb/tmp/exec01 

Breakpoint 1, fib (n=5) at code01.c:5
9	    if (n <= 1)
(gdb) 

این جا می‌خوایم ببینیم سورس کد برنامه‌مون چه شکلیه! برای این کار به راحتی دستور list رو اجرا می‌کنیم:

(gdb) list
4	
5	
6	
7	int fib(int n)
8	{
9	    if (n <= 1)
10	        return n;
11	    int x = fib(n - 1);
12	    int y = fib(n - 2);
13	    return x + y;
(gdb) list
14	}
15	
16	int main()
17	{
18	    fib(10);
19	    return 0;
20	}
(gdb) list 0
1	#include <assert.h>
2	
3	
4	
5	
6	
7	int fib(int n)
8	{
9	    if (n <= 1)
10	        return n;
(gdb) list
11	    int x = fib(n - 1);
12	    int y = fib(n - 2);
13	    return x + y;
14	}
15	
16	int main()
17	{
18	    fib(10);
19	    return 0;
20	}
(gdb) list
Line number 21 out of range; code01.c has 20 lines.
(gdb)

در واقع دستور list، دفعه‌ی اوّل که اجرا می‌شه ۱۰ خط از برنامه‌مون(با مرکزیت خط فعلی!) رو چاپ می‌کنه. دفعه‌ی بعد، ۱۰ خط بعدی رو چاپ می‌کنه و همین طور ادامه می‌ده تا به پایان برنامه برسه. این دستور البته یه آرگومان اختیاری هم می‌تونه دریافت کنه. این آرگومان، به نوعی بهش می‌گه از چه خطی شروع به نمایش کد کنه و ادامه بده.

در کل این دستور خیلی چیز پیچیده‌ای نیست و با یه خرده بازی کردن باهاش می‌شه طرز کارش رو فهمید. D:

درس هشتم: step

این دستور خیلی کاربردیه!! طرز عملکردش خیلی شبیه دستور next هست. با این تفاوت که وقتی به فراخوانی تابعی می‌رسیم و next رو اجرا می‌کنیم، از پیچدگی‌های درونی اون تابع می‌گذره و در واقع توی همین تابع فعلی می‌مونه و سراغ دستور بعد از اون فراخوانی می‌ره. امّا step این طوری نیست و موقعی که قبل از فراخوانی یه تابع اجراش می‌کنیم، وارد اون تابع می‌شه. مثلا توی همین نقطه‌ای که برنامه‌مون وایساده، چند بار اجراش می‌کنیم!

(gdb) step
11	    int x = fib(n - 1);
(gdb) step
fib (n=4) at code01.c:9
9	    if (n <= 1)
(gdb) bt
#0  fib (n=4) at code01.c:9
#1  0x000055555555461d in fib (n=5) at code01.c:11
#2  0x000055555555461d in fib (n=6) at code01.c:11
#3  0x000055555555461d in fib (n=7) at code01.c:11
#4  0x000055555555461d in fib (n=8) at code01.c:11
#5  0x000055555555461d in fib (n=9) at code01.c:11
#6  0x000055555555461d in fib (n=10) at code01.c:11
#7  0x0000555555554648 in main () at code01.c:18
(gdb) step
11	    int x = fib(n - 1);
(gdb)

همون طور که می‌بینید، به نقطه‌ی فراخوانی fib(n-1) می‌رسیم و با اجرای دستور step، از frame کنونی که fib(5) بود، وارد fib(4) شدیم.

مثل دستورات up، down و next که یه آرگومان اختیاری می‌گرفتن که تعداد دفعات تکرارشون بود، می‌تونیم یه آرگومان به step بدیم و به جای این که یک مرحله یک مرحله جلو بریم، چند مرحله چند مرحله جلو بریم! مثلا به جای این ۲ تا step که توی همین مثال اجرا کردیم، می‌تونستیم بزنیم step 2 و کارمون کمی خلاصه‌تر بشه.

درس نهم: finish

این دستور در کنار دستور step خیلی به کار می‌آد. وقتی وسط اجرای یه تابعی هستیم، دستور finish باعث می‌شه برنامه تا آخر این تابع ادامه پیدا کنه و در نهایت به جایی که این تابع فراخوانی شده برگردیم. البته به شرطی که این وسط به breakpointی گیر نکنیم. D:

توی همین مثال فعلی‌مون، برای این که به fib(5) برگردیم:

(gdb) finish
Run till exit from #0  fib (n=4) at code01.c:11
0x000055555555461d in fib (n=5) at code01.c:11
11	    int x = fib(n - 1);
Value returned is $1 = 3
(gdb) step
12	    int y = fib(n - 2);
(gdb) print x
$2 = 3
(gdb)

همون طور که خود gdb هم بهمون گفت، اجرای fib(4) تموم شد و به نقطه‌ای که این تابع فراخوانی شده بود برگشتیم. یعنی خط ۱۱م برنامه توی fib(5).

خب... این سری از آموزش gdb رو هم توی این نقطه تموم می‌کنیم. ولی یادتون باشه با استفاده از دستور help توی gdb می‌تونید هر اطّلاعاتی خواستید راجع به دستورات مختلف به دست بیارید و کاستی‌های این آموزش رو جبران کنید. در واقع هدف من از این آموزش‌ها اینه که کسایی که مشتاق هستن، با اصول اوّلیه‌ی gdb آشنا بشن تا بتونن بعدا با سرچ و help و... راحت‌تر گلیم خودشون رو از آب بیرون بکشن.

وگرنه، نه من اون قدری gdb بلد هستم که بخوام کلّش رو یاد بدم، نه کل gdb نیاز همه‌ی آدم‌ها می‌شه و نه اصلا gdb اون قدری دنیای کوچیکی داره که حتّی اگر من بلد بودم، حوصله داشتم در موردش بنویسم. :))

همین دیگه...

و من الله التوفیق!