ഗ്നു ഡീബഗ്ഗർ അല്ലെങ്കിൽ ജിഡിബി: ലിനക്സ് പ്രോഗ്രാമുകൾക്കുള്ള ശക്തമായ സോഴ്സ് കോഡ് ഡീബഗ്ഗിംഗ് ടൂൾ

ഏതൊരു സോഫ്റ്റ്uവെയർ ഡെവലപ്uമെന്റ് സിസ്റ്റത്തിലും ഒരു ഡീബഗ്ഗർ ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു. ഒറ്റയടിക്ക് ആർക്കും ബഗ് ഫ്രീ കോഡ് എഴുതാൻ കഴിയില്ല. വികസന വേളയിൽ, ബഗുകൾ ഉയർന്നുവരുന്നു, കൂടുതൽ മെച്ചപ്പെടുത്തുന്നതിന് അത് പരിഹരിക്കേണ്ടതുണ്ട്. ഒരു ഡീബഗ്ഗർ ഇല്ലാതെ ഒരു വികസന സംവിധാനം അപൂർണ്ണമാണ്. ഓപ്പൺ സോഴ്uസ് ഡെവലപ്പേഴ്uസ് കമ്മ്യൂണിറ്റി കണക്കിലെടുക്കുമ്പോൾ, ഗ്നു ഡീബഗ്ഗർ അവരുടെ ഏറ്റവും മികച്ച ചോയിസാണ്. UNIX തരം പ്ലാറ്റ്uഫോമുകളിൽ വാണിജ്യ സോഫ്റ്റ്uവെയർ വികസനത്തിനും ഇത് ഉപയോഗിക്കുന്നു.

GDb എന്നും അറിയപ്പെടുന്ന GNU ഡീബഗ്ഗർ, കോഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോഴോ അല്ലെങ്കിൽ ഒരു പ്രോഗ്രാം ക്രാഷാകുന്നതിന് മുമ്പ് എന്താണ് ചെയ്യാൻ ശ്രമിക്കുന്നതെന്നോ അതിലൂടെ കടന്നുപോകാൻ ഞങ്ങളെ അനുവദിക്കുന്നു. സോഴ്uസ് കോഡിലെ പിഴവുകൾ കണ്ടെത്തുന്നതിന് നാല് പ്രധാന കാര്യങ്ങൾ ചെയ്യാൻ GDB അടിസ്ഥാനപരമായി നമ്മെ സഹായിക്കുന്നു.

പൊതു സ്വഭാവത്തെ ബാധിച്ചേക്കാവുന്ന ആർഗ്യുമെന്റുകൾ വ്യക്തമാക്കി പ്രോഗ്രാം ആരംഭിക്കുക.
നിർദ്ദിഷ്ട വ്യവസ്ഥകളിൽ പ്രോഗ്രാം നിർത്തുക.
ക്രാഷ് അല്ലെങ്കിൽ പ്രോഗ്രാം എപ്പോൾ നിർത്തിയെന്ന് പരിശോധിക്കുക.
കോഡ് മാറ്റുകയും പരിഷ്കരിച്ച കോഡ് തൽക്ഷണം പരീക്ഷിക്കുകയും ചെയ്യുക.

C, C++ എന്നിവയിൽ എഴുതിയ പ്രോഗ്രാമുകൾ ഡീബഗ് ചെയ്യാൻ നമുക്ക് gdb ഉപയോഗിക്കാം. D, Modula-2, Fortran പോലുള്ള മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകൾക്കുള്ള പിന്തുണ ഇപ്പോൾ ഭാഗികമാണ്.

GNU Debugger അല്ലെങ്കിൽ GDB ഉപയോഗിച്ച് ആരംഭിക്കുന്നു

gdb കമാൻഡ് ഉപയോഗിച്ചാണ് GDB അഭ്യർത്ഥിക്കുന്നത്. gdb നൽകുമ്പോൾ, അത് പ്ലാറ്റ്uഫോമിനെക്കുറിച്ചുള്ള ചില വിവരങ്ങൾ പ്രദർശിപ്പിക്കുകയും താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ (gdb) പ്രോംപ്റ്റിലേക്ക് നിങ്ങളെ എത്തിക്കുകയും ചെയ്യുന്നു.

gdb

GNU gdb (GDB) Fedora 7.6.50.20130731-19.fc20 
Copyright (C) 2013 Free Software Foundation, Inc. 
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> 
This is free software: you are free to change and redistribute it. 
There is NO WARRANTY, to the extent permitted by law.  Type "show copying" 
and "show warranty" for details. 
This GDB was configured as "x86_64-redhat-linux-gnu". 
Type "show configuration" for configuration details. 
For bug reporting instructions, please see: 
<http://www.gnu.org/software/gdb/bugs/>. 
Find the GDB manual and other documentation resources online at: 
<http://www.gnu.org/software/gdb/documentation/>. 
For help, type "help". 
Type "apropos word" to search for commands related to "word". 
(gdb)

gdb-യിൽ ലഭ്യമായ വിവിധ തരം കമാൻഡുകൾ പുറത്തെടുക്കാൻ help ലിസ്റ്റ് ടൈപ്പ് ചെയ്യുക. ആ ക്ലാസിലെ കമാൻഡുകളുടെ ഒരു ലിസ്റ്റിനായി ഒരു ക്ലാസ് നാമത്തിന് ശേഷം help എന്ന് ടൈപ്പ് ചെയ്യുക. എല്ലാ കമാൻഡുകളുടെയും ലിസ്റ്റിനായി എല്ലാവരെയും സഹായിക്കുക എന്ന് ടൈപ്പ് ചെയ്യുക. അവ്യക്തമാണെങ്കിൽ കമാൻഡ് നാമത്തിന്റെ ചുരുക്കങ്ങൾ അനുവദനീയമാണ്. ഉദാഹരണത്തിന്, തുടരുക എന്നതിന് അടുത്തത് അല്ലെങ്കിൽ സി ടൈപ്പുചെയ്യുന്നതിന് പകരം നിങ്ങൾക്ക് n എന്ന് ടൈപ്പുചെയ്യാം.

സാധാരണയായി ഉപയോഗിക്കുന്ന gdb കമാൻഡുകൾ ഇനിപ്പറയുന്ന പട്ടികയിൽ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു. ഈ കമാൻഡുകൾ gdb കമാൻഡ് പ്രോംപ്റ്റിൽ (gdb) ഉപയോഗിക്കേണ്ടതാണ്.

ഘട്ടം, അടുത്തത് എന്നീ രണ്ട് കമാൻഡുകൾ തമ്മിലുള്ള വ്യത്യാസം ശ്രദ്ധിക്കുക. അടുത്ത വരി ഒരു ഫംഗ്uഷൻ കോളാണെങ്കിൽ അടുത്ത കമാൻഡ് ഫംഗ്uഷനിലേക്ക് പോകില്ല. അതേസമയം step കമാൻഡിന് അകത്ത് ഫംഗ്uഷനിലേക്ക് പോയി അവിടെ എന്താണ് സംഭവിക്കുന്നതെന്ന് കാണാൻ കഴിയും.

ഇനിപ്പറയുന്ന സോഴ്സ് കോഡ് പരിഗണിക്കുക.

// sum.c
#include <stdio.h> 

int sum (int a, int b) { 
	int c; 
	c = a + b; 
	return c; 
} 

int main() { 
	int x, y, z; 
	printf("\nEnter the first number: "); 
	scanf("%d", &x); 
	printf("Enter the second number: "); 
	scanf("%d", &y); 
	z = sum (x, y); 
	printf("The sum is %d\n\n", z); 
	return 0; 
}

ഔട്ട്uപുട്ട് ഫയൽ ഡീബഗ് ചെയ്യുന്നതിനായി, ഇനിപ്പറയുന്ന രീതിയിൽ gcc-ലേക്ക് -g ഓപ്ഷൻ ഉപയോഗിച്ച് കംപൈൽ ചെയ്യേണ്ടതുണ്ട്.

$ gcc -g sum.c -o sum

ഔട്ട്uപുട്ട് ഫയൽ സം ഇനിപ്പറയുന്ന 2 വഴികളിൽ ഒന്നിലൂടെ gdb-ലേക്ക് അറ്റാച്ചുചെയ്യാനാകും:

1. ഔട്ട്uപുട്ട് ഫയൽ gdb-യിലേക്കുള്ള ആർഗ്യുമെന്റായി വ്യക്തമാക്കുന്നതിലൂടെ.

$ gdb sum

2. file കമാൻഡ് ഉപയോഗിച്ച് gdb-യ്ക്കുള്ളിൽ ഔട്ട്uപുട്ട് ഫയൽ പ്രവർത്തിപ്പിക്കുന്നു.

$ gdb
(gdb) file sum

ലിസ്റ്റ് കമാൻഡ് സോഴ്സ് കോഡ് ഫയലിലെ വരികൾ ലിസ്റ്റ് ചെയ്യുകയും പോയിന്റർ നീക്കുകയും ചെയ്യുന്നു. അതിനാൽ ആദ്യം ലിസ്റ്റ് ആദ്യത്തെ 10 വരികൾ പ്രദർശിപ്പിക്കും, അടുത്ത ലിസ്റ്റ് അടുത്ത 10 എന്നിവയും മറ്റും പ്രദർശിപ്പിക്കും.

(gdb) list
1	#include <stdio.h>   
2	 
3	int sum (int a, int b) { 
4		int c; 
5		c = a + b; 
6		return c; 
7	} 
8	 
9	int main() { 
10		int x, y, z;

എക്സിക്യൂഷൻ ആരംഭിക്കുന്നതിന്, run കമാൻഡ് നൽകുക. ഇപ്പോൾ പ്രോഗ്രാം സാധാരണ രീതിയിൽ നടപ്പിലാക്കുന്നു. എന്നാൽ ഡീബഗ്ഗിംഗിനായി സോഴ്സ് കോഡിൽ ചില ബ്രേക്ക്പോയിന്റുകൾ ഇടാൻ ഞങ്ങൾ മറന്നു, അല്ലേ? ഈ ബ്രേക്ക്uപോയിന്റുകൾ ഫംഗ്uഷനുകൾക്കോ നിർദ്ദിഷ്ട ലൈനുകളിലോ വ്യക്തമാക്കാം.

(gdb) b main

കുറിപ്പ്: ബ്രേക്ക് എന്നതിന് ഞാൻ ഒരു ചുരുക്കെഴുത്ത് ഉപയോഗിച്ചു.

പ്രധാന ചടങ്ങിൽ ബ്രേക്ക് പോയിന്റ് സജ്ജീകരിച്ച ശേഷം, പ്രോഗ്രാം വീണ്ടും പ്രവർത്തിപ്പിക്കുന്നത് വരി 11-ൽ നിർത്തും. ലൈൻ നമ്പർ മുമ്പ് അറിയാമെങ്കിൽ അതേ കാര്യം പ്രാബല്യത്തിൽ വരുത്താം.

(gdb) b sum.c:11

ഇപ്പോൾ അടുത്തത് അല്ലെങ്കിൽ n കമാൻഡ് ഉപയോഗിച്ച് കോഡിന്റെ വരികളിലൂടെ ചുവടുവെക്കുക. ഫംഗ്uഷനിൽ ഒരു ബ്രേക്ക് പോയിന്റ് സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, അടുത്തത് കമാൻഡ് ഫംഗ്uഷൻ കോഡിനുള്ളിലേക്ക് പോകില്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. നമുക്ക് ഇപ്പോൾ print കമാൻഡ് പരീക്ഷിച്ചു നോക്കാം. ഫംഗ്uഷൻ തുകയിൽ ബ്രേക്ക് പോയിന്റ് ചുവടെ സജ്ജീകരിക്കുക.

(gdb) b sum 
Breakpoint 1 at 0x4005aa: file sum.c, line 5. 
(gdb) r 
Starting program: /root/sum 

Enter the first number: 2 
Enter the second number: 3 

Breakpoint 1, sum (a=2, b=3) at sum.c:5 
5		c = a + b; 
(gdb) p a 
$1 = 2 
(gdb) p b 
$2 = 3
(gdb) c 
Continuing. 
The sum is 5 

[Inferior 1 (process 3444) exited normally]

റൺ ചെയ്യുന്ന പ്രോഗ്രാമിന് കമാൻഡ് ലൈൻ പാരാമീറ്ററുകൾ ആവശ്യമാണെങ്കിൽ, run എന്ന കമാൻഡിനോടൊപ്പം അത് നൽകുക.

(gdb) run   . . .

നിലവിൽ പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമുമായി ബന്ധപ്പെട്ട പങ്കിട്ട ലൈബ്രറി ഫയലുകൾ ഇങ്ങനെ ലിസ്റ്റ് ചെയ്യാം.

(gdb) info share 
From                To                  Syms Read   Shared Object Library 
0x00000035a6000b10  0x00000035a6019c70  Yes         /lib64/ld-linux-x86-64.so.2 
0x00000035a641f560  0x00000035a6560bb4  Yes         /lib64/libc.so.6

പ്രോഗ്രാമിന്റെ നിർവ്വഹണത്തിലുടനീളം വേരിയബിളുകൾ പരിഷ്കരിക്കാനും GDB പ്രാപ്തമാണ്. നമുക്ക് ഇത് പരീക്ഷിച്ചു നോക്കാം. മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, വരി 16-ൽ ബ്രേക്ക് പോയിന്റ് സജ്ജമാക്കി പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക.

(gdb) r 
Starting program: /root/sum 

Enter the first number: 1 
Enter the second number: 2 

Breakpoint 1, main ( ) at sum.c:16 
16		printf("The sum is %d\n\n", z); 
(gdb) set z=4 
(gdb) c 
Continuing. 
The sum is 4

ഇപ്പോൾ a = 1, b = 2, ഫലം z = 3 ആയിരിക്കണം. എന്നാൽ ഇവിടെ പ്രധാന ഫംഗ്uഷനിൽ ഞങ്ങൾ അന്തിമ ഫലം z = 4 ആയി മാറ്റി. ഇതുവഴി ജിഡിബി ഉപയോഗിച്ച് ഡീബഗ്ഗിംഗ് എളുപ്പമാക്കാം.

എല്ലാ ബ്രേക്ക്uപോയിന്റുകളുടെയും ലിസ്റ്റ് ലഭിക്കാൻ ഇൻഫോ ബ്രേക്ക്uപോയിന്റുകൾ എന്ന് ടൈപ്പ് ചെയ്യുക.

(gdb) info breakpoints 
Num     Type           Disp Enb Address            What 
1       breakpoint     keep y   0x00000000004005c2 in main at sum.c:11

ഇവിടെ ഒരു ബ്രേക്ക് പോയിന്റ് മാത്രമേയുള്ളൂ, അത് To ആണ്. പ്രവർത്തനക്ഷമമാക്കി ബ്രേക്ക്uപോയിന്റുകൾ പ്രവർത്തനരഹിതമാക്കുക അപ്രാപ്uതമാക്കുക കമാൻഡിനോടൊപ്പം ബ്രേക്ക്uപോയിന്റ് നമ്പർ വ്യക്തമാക്കുന്നു. പിന്നീട് പ്രവർത്തനക്ഷമമാക്കാൻ enable കമാൻഡ് ഉപയോഗിക്കുക.

(gdb) disable 1 
(gdb) info breakpoints 
Num     Type           Disp Enb Address            What 
1       breakpoint     keep n   0x00000000004005c2 in main at sum.c:11

ഇല്ലാതാക്കുക കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ബ്രേക്ക്uപോയിന്റുകൾ ഇല്ലാതാക്കാനും കഴിയും.

ഒരു ഗ്നു/ലിനക്സ് സിസ്റ്റത്തിൽ നിരവധി പ്രക്രിയകൾ പശ്ചാത്തലത്തിൽ പ്രവർത്തിക്കുന്നു. ഒരു റണ്ണിംഗ് പ്രോസസ് ഡീബഗ് ചെയ്യുന്നതിന് ആദ്യം നമ്മൾ ആ പ്രത്യേക പ്രക്രിയയുടെ പ്രോസസ്സ് ഐഡി കണ്ടെത്തേണ്ടതുണ്ട്. pidof കമാൻഡ് നിങ്ങൾക്ക് ഒരു പ്രക്രിയയുടെ pid നൽകുന്നു.

$ pidof <process_name>

ഇപ്പോൾ നമുക്ക് ഈ പിഡ് ജിഡിബിയിലേക്ക് അറ്റാച്ചുചെയ്യേണ്ടതുണ്ട്. 2 വഴികളുണ്ട്.

1. gdb-യ്uക്കൊപ്പം pid വ്യക്തമാക്കുന്നതിലൂടെ.

$ gdb -p <pid>

2. gdb-ൽ നിന്നുള്ള അറ്റാച്ച് കമാൻഡ് ഉപയോഗിക്കുന്നു.

(gdb) attach <pid>

ഇപ്പോഴത്തേക്ക് ഇത്രമാത്രം. സോഴ്uസ് കോഡ് ഡീബഗ്ഗ് ചെയ്യുന്നതിൽ നല്ല തുടക്കം ലഭിക്കുന്നതിനുള്ള ജിഡിബിയുടെ അടിസ്ഥാനകാര്യങ്ങൾ മാത്രമാണ് ഇവ, മുകളിൽ വിവരിച്ച കാര്യങ്ങളെക്കാൾ വളരെ കൂടുതലാണ്. ഉദാഹരണത്തിന്, സ്റ്റാക്ക് വിവരങ്ങളും എൻവയോൺമെന്റ് വേരിയബിളുകളും മറ്റും ഉപയോഗിച്ച് നമുക്ക് ഡീബഗ് ചെയ്യാം. ഈ എല്ലാ കാര്യങ്ങളും ഉപയോഗിച്ച് കളിക്കാൻ ശ്രമിക്കുക...