The GNU Debugger (gdb)

A symbolic debugger is a program that aids programmers in finding logical errors, by allowing them to execute their program in a controlled manner. More precisely, a debugger allows a programmer to step through a program one statement at a time, and examine the values of variables (and expressions) following the execution of each statement. This allows a programmer to find the statement responsible for a logical error involving a particular variable by stepping through the program a statement at a time and examining the value of variable after each statement executes.

Although there are several debuggers available on UNIX systems, we will look at the GNU symbolic debugger, gdb. In addition to allowing programmers to edit and compile their programs, emacs also interacts with gdb.

Getting Started

Whereas a high-level program operates on variables, a machine-level program operates on addresses. A compiler must therefore translate each variable into an address and must store (among other things) these associations of variables with addresses in a special dictionary, called a symbol table so that it can look up an identifier when it encounters a reference to it and find its address.

The symbol table is usually discarded when compilation is complete. Some way is needed to instruct the compiler to keep it for use by the debugger. For the GNU C++ compiler, this is done with the -g switch.

g++ -g -c prog.cc
g++ -g -c lib.cc
g++ -g prog.o lib.o -o prog

To use gdb to debug a binary file prog (including lib), one can invoke it from the command line:

gdb prog

1. Move the cursor to the *compilation* window (or create a new one) and
2. Invoke gdb with the emacs command M-x gdb

run gdb (like this): gdb

run gdb (like this): gdb prog

(gdb)

Gdb Commands

Quitting gdb

(gdb) quit (or q or Ctrl-D)

Setting Breakpoints
Setting a breakpoint permits you to mark a particular line in your program (called a breakpoint) so that when execution reaches that line, program execution will be suspended, allowing you to enter a gdb command.

To set a breakpoint:

1. Move the cursor to the desired line in the source-code window
2. Give the emacs command: Ctrl-x SPACEBAR (Control-x followed by the spacebar)

(gdb) Breakpoint 1 at 0x22d0: file prog.cc, line 12.

Removing Breakpoints

(gdb) clear line-number

(gdb) clear 12

Starting Execution of Program

(gdb) run (or r)

Resuming Execution at a Breakpoint
Once you have suspended execution at a particular statement, you can resume execution in several ways:

continue (or c)

Resumes execution and continues until the next breakpoint or until execution is completed.

next (or n)

step (or s)

You can execute just the next statement in two ways: the next command will execute the statement pointed to by the arrow in its entirety, and move the arrow to the following statement. This is particularly important when the statement contains a function call, because next will execute a function in the current statement in its entirety.

By contrast, the step command will execute the next statement, but will step into function calls. That is, if the statement pointed to by the arrow contains a function call, then the next statement to be executed will be the first line of that function. The step command enables you to execute a called function one statement at a time, whereas the next command confines you to your main (or currently executing) function. When execution passes from one function to another, gdb displays the name of the function, plus the value of each argument passed to its parameters, allowing you to examine what is happening when the function is called and to check if its parameters are receiving the arguments you were expecting them to get.

print expression (or p expression)

Displays the value of the expression (usually a variable) once → at the current point of execution. This is especially useful when a program crashes at a particular statement or we suspect that the statement is where there is a logical error. We can use print to display the value of each of the variables in that statement.

display expression

Displays the value of the expression (usually a variable) each time execution is suspended (e.g., at breakpoints, when next or step command is used, etc.) in a format like

1: Counter = 0

This is useful when we suspect one or more variables as causing the program to work incorrectly, but we don't know where they are receiving their bad values.

info display

Displays a numbered list of all expressions currently being displayed.

undisplay num

Stop displaying expression number num.

More?
You can learn about these gdb commands and others using the help command:

(gdb) help

man gdb

source_lab05_sphere.cpp 
/* Program to compute the surface area and volume of a sphere 
 * having a given radius.
 * Input: radius
 * Output: radius and volume
 -------------------------------------------------------------------*/

#include <iostream> 
using namespace std; 

const double PI = 3.14159265359; 

void GetRadius( double & radius); 
void ShowResults( double rad, double area, double vol); 

int main() 
{ 
cout << "Program computes surface area and volume of a sphere.\n"; 

double radius,        // radius of sphere 
       surfaceArea,   // its surface area 
       volume;        // its volume 

GetRadius( radius); 
volume = surfaceArea * radius / 3.0; 
surfaceArea = 4.0 * PI * radius * radius; 

ShowResults(radius, surfaceArea, volume); 
return 0; 
} 

void GetRadius(double & rad) 
{ 
cout << "Enter radius of sphere: "; 
cin >> rad; 
} 

void ShowResults(double rad, double area, double vol) 
{ 
cout << "Radius of sphere is " << rad << " inches\n"; 
cout << "Its surface area is " << area << "sq. inches\n" 
<< "Its volume is " << vol << " cubic inches.\n\n"; 
} 

LAB Exercise 2b: Using the gnu Debugger gdb

1. Open an emacs window containing source_lab05_sphere.cpp (you can download it here source_lab05_sphere.cpp).
2. Compile the program using the -g switch: g++ -g source_lab05_sphere.cpp -o sphere
3. Invoke gdb (remember, in Emacs you should say M-x gdb and then gdb sphere).
4. Start sphere executing by using gdb's run command. Note that the program executes normally, stopping only for you to input values and when execution is finished. What output is produced by the program?
   
   
   
   
   
5. The program obviously contains an error. It isn't difficult to find, but let's do so with the aid of the debugger. Set a breakpoint at the first output statement in source_lab05_sphere.cpp . What message appears in the gdb window?
   
   
   
   
   
6. Start sphere executing again with gdb's run command. What message is produced when execution halts?
   
   
   
   
   Where is the arrow pointing in the source window?
   
   
   
   
   
7. Use gdb's continue command. Describe what happens.
   
   
   
   
   
8. After the execution is finished , give the run command again. Then use next to move to the first function call, that is, to the line

   GetRadius( radius);

   (Note that blank lines and declarations are passed over.) Use next to "step over" this function call. You should be prompted to enter a radius. Do so (but do not enter '3'). The arrow should move to the first assignment statement. Use the print command to display the value of radius. What output is produced?
   
   
   
   
   Use the display command to display the value of volume. What output (if any) is produced?
   
   
   
   
   

9. Use next to execute the first assignment statement. What output is produced?
   
   
   
   
   But we just assigned a value to volume, didn't we? Let's check the values used in the assignment. Print the value of radius. What is it? Is it correct?
   
   
   
   
   Print the value of surfaceArea. What is it? Is it correct?
   
   
   
   
   
10. With a little thought, it should be clear that the problem is that we've used the value of surfaceArea before computing it (in the next assignment statement). Terminate the debugger and fix the program (by switching the two assignment statements.)
11. Recompile and get the debugger running as before, but this time, set two breakpoints:
    One at the first output statement.
    Another at the call to function ShowResults().
    When execution reaches the first breakpoint, display the values of PI, radius, surfaceArea, and volume. Now give the info display command. What output is produced?
    
    
    
    
    
12. Turn off the display of PI (using undisplay). Use info display again to check that it has been removed.
13. Give the continue command. Enter a value for the radius. Now, where does execution halt? Why did it stop there?
    
    
    
    
    
14. Use the step command to step into ShowResults(). What output is produced?
    
    
    
    
    Are the parameter values correct?
    
    
    
    
    
15. Finish executing the program and terminate the debugger.