Development/GDB

GDB: The GNU Project Debugger
module load	devel/gdb
License	GPL
Citing
Links	Homepage; Documentation; Wiki; Mailinglists
Graphical Interface	No
Included in module

The GNU Debugger (GDB) is a standard debugger for serial programs although it can be used for parallel and even distributed programs with few processes too. The Intel Debugger (IDB) uses the same commands for basic debugging as GDB and hence can be used instead of GDB just by substituting idbc for gdb.

Loading

It is possible to choose between several versions of GDB and GCC. By default both programms are installed. You can check the version which is currently used with:

$ gdb --version

$ gcc --version

To use a different version of GCC or GDB, you have to load it through the module system. For example you need GDB 7.7 or higher for GCC version 4.8 and above. In this case load the devel/gdb module.

How to check which versions are available:

$ module avail

How to load the desired version (e.g. GDB version 7.7):

$ module load devel/gdb/7.7

If you want to use IDB load the Intel compiler module:

$ module load compiler/intel

Documentation

For online documentation see the links section in the summary table at the top of this page. For local documentation consult the man page.

$ man gdb

or

$ man idb

Basic commands

The code you want to debug should be compiled with the -g option. If the optimization flag is not set, the GCC will still do some basic optimization. Therefore, it is recommended to turn off the optmization explicitly with the -O0 parameter for debugging. To start a debug session for a program execute GDB with the program path as parameter:

$ gdb ./example

Inside GDB is a prompt where you can enter commands. Important commands are listed below.

Command	Description
help cmd	Show help for command cmd.
break func	Set a breakpoint at function func.
run	Start program.
next	Go to next program line. Do not enter functions.
step	Go to next program line. Enter functions.
list	Show the surrounding source code of the currently processed line.
print expr	Print the value of the expression expr.
display expr	Display the value of the expression expr every time the program stops.
watch expr	Stop when value of the expression expr changes.
continue	Continue execution until a breakpoint or a watchpoint appears.
backtrace	Print a list of functions that are currently active.
quit	Exit GDB.

Example: We debug the following program called bug.c which crashes on execution.

#include <stdio.h>

int global = 0;

void begin() {
    global = 1;
}

void loop() {
    int v[2];
    int i, k;

    for(i = 0; i < 8; i++) {
        k = i/2*2;	/* should have been k = i/(2*2); */
        v[k] = i;
    }
}

void end() {
    global = 2;
}

int main() {
    begin();
    loop();
    end();

    return 0;
}

Sample GDB session:

$ gcc -g bug.c -o bug
$ gdb ./bug
GNU gdb (GDB) Red Hat Enterprise Linux (7.2-60.el6_4.1)
Copyright (C) 2010 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".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /pfs/data2/home/xx/xxx/xxxx/bug...done.
(gdb) break main
Breakpoint 1 at 0x4005b2: file bug.c, line 26.
(gdb) run
Starting program: /pfs/data2/home/xx/xxx/xxxx/bug

Breakpoint 1, main () at bug.c:26
26              begin();
Missing separate debuginfos, use: debuginfo-install glibc-2.12-1.132.el6.x86_64 libgcc-4.4.7-4.el6.x86_64
(gdb) next
27              loop();
(gdb) next

Program received signal SIGSEGV, Segmentation fault.
0x0000000000000005 in ?? ()
(gdb) # now we know that the bug is in loop(). start again.
(gdb) run
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /pfs/data2/home/xx/xxx/xxxx/bug

Breakpoint 1, main () at bug.c:26
26              begin();
(gdb) next
27              loop();
(gdb) step
loop () at bug.c:13
13              for(i = 0; i < 8; i++)
(gdb) next
15                      k = i/2*2;
(gdb) next
16                      v[k] = i;
(gdb) # maybe k gets too big?
(gdb) watch (k >= 2)
Hardware watchpoint 2: (k >= 2)
(gdb) continue
Continuing.
Hardware watchpoint 2: (k >= 2)

Old value = 0
New value = 1
loop () at bug.c:16
16                      v[k] = i;
(gdb) # k is too big
(gdb) print k
$1 = 2
(gdb) print i
$2 = 2
(gdb) quit

Core dumps

When the program crashes, a log file (called core dump) can be created which contains the state of the program when it crashed. This is turned off by default because these core dumps can get quite large. If you want to turn it on you have to change your ulimits, for example:

$ ulimit -c unlimited

Every time your program crashes a new file called core.xxx (where xxx is a number) will be created in the directory from which you started the executable. You can call gdb to examine your core dump using the following command (assuming your program is called ex):

$ gdb ./ex core.xxx

Now you can print a backtrace to check in which function the error happened and what values the parameters had. Additionally you can examine the values of your variables to reproduce the error.

Multithreaded debugging

GDB can also be useful for multithreaded applications for example when OpenMP was used. By going through each thread separately you can better see what is really going on and you can check the computation step by step. The following commands are useful for multithreaded debugging:

Command	Description
info threads	Shows the status of all existing threads.
thread num	Switches to the thread with the number num

Example: We debug the following program called thread_bug.c which crashes on execution.

#include <stdio.h>
#include <pthread.h>

pthread_t thread;

void* thread3 (void* d)
{
    int w[2];
    int c, l;

    for(c = 0; c < 8; c++) {
        l = c/(2*2);	/* should have been l = c/(2*2); */
        w[l] = c;
    }

    return NULL;
}

void* thread2 (void* d)
{
    int v[2];
    int i, k;

    for(i = 0; i < 8; i++) {
        k = i/2*2;	/* should have been k = i/(2*2); */
        v[k] = i;
    }

    return NULL;
}

int main (){

    pthread_create (&thread, NULL, thread2, NULL);
    pthread_create (&thread, NULL, thread3, NULL);
  
    //Thread 1
    int count1 = 0;

    while(count1 < 4000){
      printf("Thread 1: %d\n", count1++);
    }

    pthread_join(thread, NULL);
    return 0;
}

Sample GDB thread session:

$ gcc -g thread_bug.c -o thread_bug -lpthread
$ gdb ./thread_bug