GDB Tutorial

A debugger is a program that runs other programs, allowing the user to exercise control over these programs, and to examine variables when problems arise. The most popular debugger for UNIX systems is GDB, the GNU debugger. GDB has tons of features, however, you only need to use a few for it to be very helpful. There is complete documentation for GDB online, or you can read the man page.

Basic features of a debugger

When you execute a program that does not behave as you like, you need some way to step through your logic other than just looking at your code. Some things you want to know are:

What are the values of program variables at a particular point during execution of the program?
What is the result of a particular expression in a program?
Does the program follow an expected path?
What statement or expression did the program crash on?
If an error occurs while executing a function, what line of the program contains the call to that function, and what are the parameters?

Starting GDB

need program args.c

You need to tell the gcc compiler that you plan to debug your program. You use the -g flag to do this. The command will now look something like:

gcc -g -Wall -o args args.c

which would create the example executable. To run this under the control of gdb, you type

gdb args

This starts up the text interface to the debugger.

GDB commands

When gdb starts, your program is not actually running. It won't run until you tell gdb how to run it. Whenever the prompt appears, you have any command available to you. You will usually only use a small amount of commands though, which are covered below.

run command-line-arguments
Starts your program as if you had typed
```
trees command-line-arguments
```
break place
Creates a breakpoint; the program will halt when it gets there. The most common breakpoints are at a specific line in a source file:
```
(gdb) break 20

Breakpoint 2 at 0x2290: file main.c, line 20
```
You can also set breakpoints at the beginnings of functions, as in:
```
(gdb) break Traverse

Breakpoint 2 at 0x2290: file main.c, line 20
```
The command break main stops at the beginning of execution.

If you desire for a breakpoint to be in a different file from the one containing
```
     main()
```
then you must state the name of the file with a colon, then the line number as such:
```
     break somefile.c:20
```
When you run your program and it hits a breakpoint, you'll get a message and prompt like this.
```
Breakpoint 1, Traverse(head=0x6110, NumNodes=4)

  at main.c:16

(gdb)
```
delete N
Removes breakpoint number N. Leave off N to remove all breakpoints. info break gives info about each breakpoint
clear N
Clear breakpoint at specified line or function. Argument may be line number or function name. No argument to clear all breakpoints. info break gives info about each breakpoint

info breakpoints
Lists information about every breakpoint that is currently set.
help command
Provides a brief description of a GDB command or topic. Plain help lists the possible topics. help topic displays help for the specific topic.
where
Gives the line and file you are currently located at.
directory [list of dirs]
Adds more directories to the search path for gdb. Allows the debugging of source files located in multiple directories.
step
Executes the current line of the program and stops on the next statement to be executed
next
Like step, however, if the current line of the program contains a function call, it executes the function and stops at the next line. step however would put you at the first line at the start of the called function
continue
Continues regular execution of the program until a breakpoint is hit or the program stops
backtrace
Produces a backtrace - the chain of function calls that brought the program to its current place. The command backtrace is equivalent. This command is especially useful for when your program crashes. You may see the method and line number of the crash and may examine the values of data at that time.
print /F E
prints the value of E in the specified format, variables accessible are those of the lexical environment of the selected stack frame, plus all those whose scope is global or an entire file. E can be a C expression (usually just a variable though). /F is a format type, which can be:
- x - hexadecimal
- d - decimal
- u - unsigned
- a - ascii
- c - character
quit
Leave GDB. Answer yes to exit even though your program is still running.

The goal of gdb is to give you enough info to pinpoint where your program crashes, and find the bad pointer that is the cause of the problem. Although the actual error probably occurred much earlier in the program, figuring out which variable is causing trouble is a big step in the right direction.