GDB 10-Minute tutorial

GDB 10-Minute tutorial

Author: Liigo
Original link: http://blog.csdn.net/liigo/archive/2006/01/17/582231.aspx
Date: January 16, 2006

This article is written to programs that are mainly working on Windows operating systems and need to develop some cross-platform software for ape friends, as well as program enthusiasts.

GDB is a command-line-based, powerful program debugging tool published by the GNU Open source organization under the Unix/linux operating system.

GDB commands are very many, but we only need to grasp the 10 or so of the commands, it is generally able to complete the daily major program debugging work.

Command	Explain	Demo sample
File < document name >	Loads the executable program files that are being debugged. Because GDB is normally run under the folder where the program is being debugged, the text name does not need a path.	(gdb) file Gdb-sample
R	Run, execute the program that is being debugged. Assuming that the breakpoint has not been preceded, the entire program is executed, and if there is a breakpoint, the program pauses at the first available breakpoint.	(GDB) R
C	Continue, continue to run the debugged program until the next breakpoint or program ends.	(GDB) C
b < line number > b < function name > b *< Function name > b *< Code address > d [NUMBER]	B:breakpoint, set a breakpoint. Both can specify the breakpoint location by using the line number function name, run address, and so on. The "*" symbol in front of the function name indicates that the breakpoint is set to "Prolog code generated by the compiler". If you do not understand the assembly, you can disregard the use of this method. D:delete Breakpoint, delete a breakpoint of the specified number, or delete all breakpoints. The breakpoint number is incremented from 1.	(GDB) B 8 (GDB) B main (GDB) B *main (GDB) B *0x804835c (GDB) d
S, n	S: Run a line of source code, assuming that there is a function call in this line code, then enter the function; N: Runs a line of source code, and the function calls in this line of code run as well. S is equivalent to "step into (single-step tracking entry)" in other debuggers; N is equivalent to "step over" in other debuggers. These two commands must be able to be used in the case of Source debugging information (the "-G" parameter is used when GCC compiles).	(GDB) s (GDB) n
Si, ni	The SI command is similar to the S command, the NI command is similar to the n command. The difference is that the two commands (Si/ni) are for assembly instructions, and S/n is for the source code.	(GDB) Si (gdb) NI
P < variable name >	A shorthand for print that displays the value of the specified variable (a temporary variable or a global variable).	(GDB) P I (GDB) P Nglobalvar
Display ... Undisplay < numbering >	Display, set the data to be displayed after the program is interrupted and its format. For example, suppose you want to be able to see the next assembly instruction that will be run each time the program is interrupted, and you can use the command "Display/i $pc" $PC represents the current assembly instruction,/I indicates to be displayed in 16. This command is quite useful when you need to care about assembly code. Undispaly, cancels the previous display settings, incrementing the numbering from 1.	(GDB) display/i $pc (GDB) Undisplay 1
I	For info, please refer to "Help me" for details.	(GDB) I R
Q	Quit, exit the GDB debugging environment.	(GDB) Q
Help [command name]	GDB Help command that provides an explanation of the GDB name commands. If you specify a command name parameter, the specific description of the command is displayed, and if no parameters are specified, the category displays all GDB commands for further browsing and querying by the user.	(GDB) Help display

　

Nonsense not much to say, the following begins to practice.

First give a demo sample with the small program, C language code, simple can not be simpler:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21st 22 23 24 25 26 27 28 29 30 31 32 33

//This program is only a demo sample code for "GdB 10 minute Tutorial" by Liigo //email: [email protected] //blog:http://blog.csdn.net/ Liigo //website:www.liigo.com #include <stdio.h> int nglobalvar = 0; int tempfunction (int a, int b) {     printf ("Tempfunction is called, a =%d, B =%d/n", A, b);     return (a + B); } int main () {     int n;     n = 1;     n++;     n--;     Nglobalvar + = +;     Nglobalvar-= 12;     printf ("n =%d, Nglobalvar =%d/n", n, Nglobalvar);     n = tempfunction (1, 2);     printf ("n =%d", n);     return 0; }

Please copy this code and save it to the file gdb-sample.c, then switch to the folder where this file is located and compile it with GCC:

GCC Gdb-sample.c-o gdb-sample-g

In the above command line, using the-o parameter specifies that the compiled generated executable file name is Gdb-sample, using the parameter-G to compile the source information into the executable file. Assuming that the parameter-G is not used, it can cause inconvenience to the subsequent gdb debugs. Of course, assuming that we do not have the source code of the program, it is naturally impossible to use the-G parameter, Debug/trace can only be compiled code-level debugging/tracing.

The following "GDB" command launches GDB, which displays the GDB description first, regardless of whether it:

GNU gdb Red Hat Linux (5.3POST-0.20021129.18RH) Copyright 2003 Free Software Foundation, Inc. GDB is free software, covered by the GNU general public License, and you are Welcome to change it and/or distribute copies of it under certain. Type "Show copying" to see the conditions. There is absolutely no warranty for GDB. Type "Show warranty" for details. This GDB is configured as "I386-redhat-linux-gnu". (GDB)

The last line Above "(GDB)" is the GDB internal command guide, waiting for the user to enter the GDB command.

The following uses the "file" command to load the debugged program Gdb-sample (here gdb-sample is the executable file of the previous GCC compiled output):

(gdb) file Gdb-sample Reading symbols from Gdb-sample...done.

The last line above indicates that a success has been loaded.

The following uses the "R" command to run (run) the debug file, which will run directly to the end of the program, no matter what breakpoint has been set:

(GDB) R Starting program:/home/liigo/temp/test_jmp/test_jmp/gdb-sample n = 1, Nglobalvar = 88 Tempfunction is called, a = 1, b = 2 n = 3 Program exited normally.

The following uses the "B" command to set a breakpoint at the beginning of the main function (breakpoint):

(GDB) B main Breakpoint 1 at 0x804835c:file gdb-sample.c, line 19.

The last line above indicates that the breakpoint has been successfully set and gives the breakpoint information: set a breakpoint at line 19th of the source file gdb-sample.c, which is the first breakpoint in the program (ordinal 1); The code address at the breakpoint is 0x804835c (this value may only be valid during this debugging process). Looking back at the source, the code in line 19th is "n = 1", which happens to be the first running statement in the main function ("int n;"). Defines a statement for a variable, not a statement that can be run.

Run the debug program again using the "R" command:

(GDB) R Starting program:/home/liigo/temp/gdb-sample Breakpoint 1, Main () at gdb-sample.c:19 n = 1;

The program breaks at line 19th of GDB-SAMPLE.C, where the main function is the first one to run the statement.

The last line of information above is: the next source to be run is "n = 1;", which is the 19th line in the source file gdb-sample.c.

The following runs the next line of code (that is, line 19th "n = 1;") using the "s" Command (Step). ）：

(GDB) s n++;

The above information indicates that "n = 1;" is already running and that the next code to run is "n++;" in line 20th.

Now that you have run "n = 1;", that is, assigning a value of variable N to 1, we use the "P" command (Print) to see if the value of variable n is 1:

(GDB) P n $ = 1

Sure enough, it was 1. ($ 1 Roughly means that this is the first time that the "P" command is used--running "P N" again will show "$" = "-"--this information should be of no use.) ）

Here we set a breakpoint at the beginning of line 26th and tempfunction function respectively (using the command "B" and "B tempfunction"):

(GDB) B 26 Breakpoint 2 at 0x804837b:file gdb-sample.c, line 26. (GDB) B tempfunction Breakpoint 3 at 0x804832e:file gdb-sample.c, line 12.

Using the "C" command to continue (Continue) to run the debugger, the program will break at the second breakpoint (26 lines), the value of the global variable Nglobalvar should be 88; run the "C" command again, the program will break the third breakpoint (12 lines, tempfunction At the beginning of the function), the value of the two parameters A and B of the tempfunction function should be 1 and 2 respectively:

(GDB) C Continuing. Breakpoint 2, Main () at gdb-sample.c:26 printf ("n =%d, Nglobalvar =%d/n", n, Nglobalvar); (GDB) P Nglobalvar $ = 88 (GDB) C Continuing. n = 1, Nglobalvar = 88 Breakpoint 3, Tempfunction (A=1, b=2) at Gdb-sample.c:12 printf ("Tempfunction is called, a =%d, B =%d/n", A, b); (GDB) p a $1 (GDB) P b $4 = 2

The information above feedback everything is expected, haha ~ ~ ~

Run the "C" command Again (Continue), and the program will run until the end because there are no more breakpoints behind it:

(GDB) C Continuing. Tempfunction is called, a = 1, b = 2 n = 3 Program exited normally.

　

Sometimes you need to see the compiler generated assembly code for assembly-level debugging or tracking, and how to do it?

This will use the display command "display/i $pc" (which is explained earlier in this command):

(GDB) display/i $pc (GDB)

The assembly code can then be displayed when the program is interrupted again:

(GDB) R Starting program:/home/liigo/temp/test_jmp/test_jmp/gdb-sample Breakpoint 1, Main () at gdb-sample.c:19 n = 1; 1:x/i $pc 0x804835c <main+16>: Movl $0X1,0XFFFFFFFC (%EBP)

See the assembly code, "n = 1;" The corresponding assembler code is "MOVL $0X1,0XFFFFFFFC (%EBP)".

And then each break of the program will show the next assembly designation (the "si" command is used to run a assembler code--different from "s" Running a line C code):

(GDB) Si n++; 1:x/i $pc 0x8048363 <main+23>: Lea 0XFFFFFFFC (%EBP),%eax (GDB) Si 0x08048366 n++; 1:x/i $pc 0x8048366 <main+26>: Incl (%EAX) (GDB) Si n--; 1:x/i $pc 0x8048368 <main+28>: Lea 0XFFFFFFFC (%EBP),%eax (GDB) Si 0x0804836b n--; 1:x/i $pc 0x804836b <main+31>: Decl (%eax) (GDB) Si Nglobalvar + = 100; 1:x/i $pc 0x804836d <main+33>: Addl $0X64,0X80494FC

　

Next we try the command "b *< function name >".

To be more concise, it is necessary to remove all breakpoints now (using the "D" command--delete Breakpoint):

(GDB) d Delete all breakpoints? (Y or N) y (GDB)

When asked whether to delete all breakpoints, enter "Y" and press ENTER.

The following uses the command "B *main" to set breakpoints at the Prolog code of the main function (Prolog, Epilog, respectively, the code that the compiler inserts itself at the beginning and end of each function):

Breakpoint 4 at 0x804834c:file gdb-sample.c, line. (GDB) r The program being debugged have been started already. Start it from the beginning? (Y or N) y Starting program:/home/liigo/temp/test_jmp/test_jmp/gdb-sample Breakpoint 4, Main () at Gdb-sample . c:17 1:x/i $pc 0x804834c <main>: Push%EBP (gdb) Si 0x0804834d { 1:x/i $pc 0x804834d <m AIN+1>: mov%esp,%ebp (gdb) SI 0x0804834f in Main () at Gdb-sample.c:17 + 1:x/i $pc 0x804834f <main+ 3>: Sub $0x8,%esp (gdb) Si 0x08048352 { 1:x/i $pc 0x8048352 <main+6>: and $0xfffffff0,%esp (GDB) Si 0x08048355 { 1:x/i $pc 0x8048355 <main+9>: mov $0x0,%eax (gdb) Si 0x0804835a { 1:x/i $pc 0x804835a <main+14>: Sub%eax,%esp (gdb) si n = 1; 1:x/i $pc 0x804835c <main+16>: Movl $0X1,0XFFFFFFFC (%EBP)

You can use the "I r" command to display the current value in the Register ——— "I R" or "Infomation Register":

(GDB) I R EAX 0xbffff6a4-1073744220 ECX 0x42015554 1107383636 EdX 0x40016bc8 1073834952 EBX 0x42130a14 1108544020 ESP 0xbffff6a0 0xbffff6a0 EBP 0xbffff6a8 0xbffff6a8 ESI 0x40015360 1073828704 EDI 0x80483f0 134513648 EIP 0x8048366 0x8048366 EFlags 0x386 902 CS 0x23 35 SS 0X2B 43 DS 0x2b 43 Es 0x2b 43 FS 0x0 0 GS 0x33 51

Of course, you can also display a random value of the specified register:

(GDB) I r eax EAX 0xbffff6a4-1073744220

　

The last command to introduce is "Q" and exit (quit) the GDB debug environment:

(GDB) Q The program is running. Exit anyway? (Y or N) y

All rights reserved: Liigo.com

Please obtain the permission of the author Liigo prior to reprint.

[Email protected]
Www.liigo.com
http://blog.csdn.net/liigo/
qq:175199125

GDB 10-Minute tutorial