more gdb

Introduction

The purpose of a debugger such as GDB is to allow you to see what is going on "inside" another program while it executes--or what another program was doing at the moment it crashed.

GDB can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:

• Start your program, specifying anything that might affect its behavior.
• Make your program stop on specified conditions.
• Examine what has happened, when your program has stopped.
• Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.

In order to debug a program effectively, you need to generate debugging information when you compile it. This debugging information is stored in the object file; it describes the data type of each variable or function and the correspondence between source line numbers and addresses in the executable code.

To request debugging information, specify the `-g' option when you run the compiler.

GDB Quickstart

We provide you with a list of common GDB operations which should get you going :

Stopping Execution

break

A breakpoint makes your program stop whenever a certain point in the program is reached. For each breakpoint, you can add conditions to control in finer detail whether your program stops. You can set breakpoints with the `break' command and its variants to specify the place where your program should stop by line number, function name or exact address in the program.

break FUNCTION

Set a breakpoint at entry to function FUNCTION.

break LINENUM

Set a breakpoint at line LINENUM in the current source file.

break FILENAME:LINENUM

Set a breakpoint at line LINENUM in source file FILENAME.

break FILENAME:FUNCTION

Set a breakpoint at entry to function FUNCTION found in file FILENAME.

break ... if COND

Set a breakpoint with condition COND; evaluate the expression COND each time the breakpoint is reached, and stop only if the value is nonzero--that is, if COND evaluates as true. ... stands for one of the possible arguments described above (or no argument) specifying where to break.

watch

You can use a watchpoint to stop execution whenever the value of an expression changes, without having to predict a particular place where this may happen.

watch EXPR

Set a watchpoint for an expression. GDB will break when EXPR is written into by the program and its value changes.

info

Print a table of all breakpoints and watchpoints set and not deleted, with the following columns for each breakpoint: info breakpoints [N]

info break [N]

info watchpoints [N]

clear

Delete any breakpoints at the next instruction to be executed in the selected stack frame. When the innermost frame is selected, this is a good way to delete a breakpoint where your program just stopped.

clear FUNCTION

clear FILENAME:FUNCTION

Delete any breakpoints set at entry to the function FUNCTION.

clear LINENUM

clear FILENAME:LINENUM

Delete any breakpoints set at or within the code of the specified line.

delete [breakpoints] [BNUMS...]

Delete the breakpoints or watchpoints of the numbers specified as arguments. If no argument is specified, delete all breakpoints (GDB asks confirmation, unless you have `set confirm off'). You can abbreviate this command as `d'.

Running/Resuming Execution

run

Use the `run' command to start your program under GDB. You must first specify the program name with an argument to GDB, or by using the `file' or `exec-file' command.

step

Continue running your program until control reaches a different source line, then stop it and return control to GDB. This command is abbreviated s.

step [COUNT] (shorthand s)

Continue running as in `step', but do so COUNT times. If a breakpoint is reached, or a signal not related to stepping occurs before COUNT steps, stepping stops right away.

next [COUNT] (shorthand n)

Continue to the next source line in the current (innermost) stack frame. This is similar to `step', but function calls that appear within the line of code are executed without stopping. Execution stops when control reaches a different line of code at the original stack level that was executing when you gave the `next' command. This command is abbreviated `n'.

continue [IGNORE-COUNT] (shorthand c)

Resume program execution, at the address where your program last stopped; any breakpoints set at that address are bypassed. The optional argument IGNORE-COUNT allows you to specify a further number of times to ignore a breakpoint at this location.

finish

Continue running until just after function in the selected stack frame returns. Print the returned value (if any).

Examining the Data and Source Code

print [EXP] (shorthand p)

EXP is an expression (in the source language). By default the value of EXP is printed in a format appropriate to its data type; If you omit EXP, GDB displays the last value again.

display EXP (shorthand disp)

Add the expression EXP to the list of expressions to display each time your program stops. `display' does not repeat if you press RET again after using it.

list (shorthand l)

To print lines from a source file, use the `list' command (abbreviated `l'). By default, ten lines are printed. There are several ways to specify what part of the file you want to print.

Here are the forms of the `list' command most commonly used:

list LINENUM

Print lines centered around line number LINENUM in the current source file.

list FUNCTION

Print lines centered around the beginning of function FUNCTION.

list

Print more lines. If the last lines printed were printed with a `list' command, this prints lines following the last lines printed; however, if the last line printed was a solitary line printed as part of displaying a stack frame (*note Examining the Stack: Stack.), this prints lines centered around that line.

list -

Print lines just before the lines last printed.

Examining the Stack

When your program has stopped, the first thing you need to know is where it stopped and how it got there.

Each time your program performs a function call, information about the call is generated. That information includes the location of the call in your program, the arguments of the call, and the local variables of the function being called. The information is saved in a block of data called a "stack frame". The stack frames are allocated in a region of memory called the "call stack".

backtrace (shorthand bt)

Print a backtrace of the entire stack: one line per frame for all frames in the stack.

GDB Example

First we need to compile our program using the -g flag. We will be considering the list abstract data type (ADT). Our main program contains a set of tests in creating, inserting, and searching for list elements.

$ ls Makefile list.c list.h test-list.c $ make gcc -Wall --strict-prototypes -g -c list.c gcc -Wall --strict-prototypes -g test-list.c list.o -o test-list

We are now ready to start the debugger on the executable test-list.