Highlights of this lab:

• Introduction to DBX
• Using DBX
• Examples
  1. Getting Started
  2. A Program with a Core Dump
• Summary
• References

Introduction to DBX

The dbx source code debugger is one of the most powerful tools available for programmers because it helps you locate run time errors in your source code. Run time errors, in contrast to compile time errors, are errors in the program's logic, not errors in its syntax. Run time errors only show up when you execute a program.

Run Time Errors Occur at the Different Situations:

• The program runs all right but gives undesired results.
• The program does nothing. It may be waiting for input data, or it may be stuck in an infinite loop. If it is infinitely looping, the only way you can stop the program is by typing Ctrl-C.
• The program displays output at a furious and unending rate. This usually indicates an infinite loop and Ctrl-C should be used to terminate it.
• The program produces a fatal error and generates a fatal error message. This happens when a program violates the operating system's rules by trying something like dividing by zero or accessing memory that doesn't belong to it. When a program has an error like this, UNIX takes a snapshot of its representation in memory and deposits the image in a file named core in the current directory.

Back to Highlights

Using DBX

Before you can use dbx on a program, you must compile the program using CC's -g option. That is:

	CC -g  source.cpp -o executablefile

	dbx executablefile

The dbx Debugging Process

The dbx debugger helps you debug a program by letting you control the program's execution. The debugger allows you to set breakpoints, or places in the program where execution is suspended. With the execution suspended, you can use dbx to examine the values of the program's variables and expressions. The following is an outline of a simple debugging session:

• Start dbx.
• List the program's source code.
• Set breakpoints by using the numbers displayed by the list command.
• Have dbx run the program until it encounters the first breakpoint.
• Examine the values of variables and expressions to see if they meet your expectations.
• Tell dbx to continue execution to the next breakpoint, and so on.
• Exit the dbx debugger when you have found the problem.

Commands Summary

The following is a list of the most useful commands inside dbx; the others are documented in the dbx man page (type man dbx at the UNIX command line). You will see some of these commands in action in the next section.

• quit
  This command ends the dbx session and returns to the shell. You can suspend the session by typing Ctrl-Z; restart it by typing fg.
• help
  This command prints a summary of dbx commands.
• run
  This command tells dbx to run your program. The program will run to completion unless it produces a fatal error, or unless you have told dbx to halt execution by setting breakpoints using the stop command. If your program takes command line arguments, add the arguments to the run command.
• list
  This command displays source code. If you use it without arguments, list will display the next ten lines of source code in the current source file. You can use arguments to list to specify lines of code:
  1. list linenumber1, linenumber2 displays source code lines linenumber1 through linenumber2.
     You can also use list to display a function's source code, but only if that function is part of the current source file. For instance:
  2. list function_name displays function_name's source code if function_name is part of the current source file. If the function is contained in another source file, use the file command to switch source files before using list to display the code.
• stop
  This command tells dbx to stop execution when the program reaches a specified line or function, or generates a specified condition. If you want to debug a program by suspending execution and stepping through it line by line, you must use this command to set at least one breakpoint. You can use stop as follows:
  1. stop at sourceline Stop at a specified line number in the source code.
  2. stop in function Stop when function is called.
  3. stop variable Stop when the value of variable changes.
• next
  After dbx has suspended execution, you can use this command to execute the next line of source code. If the next line is a function call, dbx will execute the entire function as though it were one line, and stop execution at the next line of the original program.
• step
  Like next, this command executes the next line of source code, but step differs from next in the following way: if the next line of source code is a function call, step will execute the first line of source within the function, and will suspend execution at the function's next line of source. You will want to use step in cases where you want to examine what happens inside specific function calls.
• cont
  This command will restart execution. The program will run to completion unless it produces a fatal error, or it reaches a breakpoint.
• print
  After dbx has stopped execution, you can use this command to display the value of a variable or expression:
  1. print variable
  2. print expression You can use print to display any valid C++ expression.
• dump
  This command displays the names and values of all currently active variables.
• trace
  This command displays tracing information as dbx executes a program:
  1. trace variable displays variable's name and value each time the program changes variable's value.
  2. trace function displays information about function each time it is called. dbx will tell you which routine made the call, the source line number of the call, what parameters were passed to the function, and what value the function returned upon completion.
  3. trace expression at sourceline displays the value of the expression as the program executes the statement at sourceline.
  4. trace sourceline displays the statement at sourceline before the program executes it. Note that sometimes trace doesn't work properly. If you try to trace an array variable in a main() function, dbx itself generates a fatal error and produces its own core file.
• status
  This command lists by number the currently active trace and stop commands.
• delete
  This command cancels trace and stop commands by command number as displayed with the status command.
• where
  This command is used when you are using dbx to examine a core file. where displays the line of code that produced the fatal error leading to the core dump. It will also list all currently active function calls. where will also tell you what breakpoint you're at if you forget it.
• assign
  This command lets you change the value of a program's variable in mid-execution. This command:

  	assign variable = variable - 1
  

  subtracts 1 from the initial value of the variable.
• delete event#
  This command deletes the breakpoint specified by the event#.
• delete all
  This command deletes all the breakpoints.

Examples

Example 1:

#include<iostream>
#include<iomanip>

using namespace std;

int main()
{
        int fahr, celsius;
        int lower, upper, step;
        lower = 0;
        step = 20;
        fahr = lower;
        upper = 10;
        cout << setw(10) << "fahr" << setw(10) << "celsius" << endl;
        while (fahr <= upper)
                {
                        celsius = 5*(fahr - 32)/9;
                        cout << setw(10) << fahr << setw(10) << celsius << endl;
                        fahr = fahr + step;
                }
        return 0;
}

Compile C++ program with -g option 
to generate information the debugger needs to connect to the source 
and executable files. 
hercules[6]% CC -g example1.cpp -o example1 
hercules[7]%
hercules[7]%
hercules[7]% example1
      fahr   celsius
         0       -17
hercules[8]%
Somehow it only prints one line of output.
We will try to use dbx to debug it.
Start dbx now. It works only with executable files. 
hercules[9]% dbx example1
changes (topic)
The major new features of this release relative to 6.0 are:

o The dbx environment variable "cfront_demangling" has been removed.
  The "-F" option to dbx (allow cfront-demangling) has also been removed.
  Use an earlier version of dbx to get cfront support.
o This release continues to support Fortran intrinsics on Intel, even
  though the Intel Fortran compiler was not shipped with WorkShop 6.
  The next dbx release will not support Fortran intrinsics on Intel.

See also `help changes60'


To suppress this message, add the following line to your .dbxrc file:

        dbxenv suppress_startup_message 5.0
Reading example1
Reading ld.so.1
Reading libCrun.so.1
Reading libm.so.1
Reading libw.so.1
Reading libc.so.1
Reading libdl.so.1
Reading libc_psr.so.1
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx)
Use list to display the source code. 
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) list
   10           lower = 0;
   11           step = 20;
   12           fahr = lower;
   13           upper = 10;
   14           cout << setw(10) << "fahr" << setw(10) << "celsius" << endl;
   15           while (fahr <= upper)
   16                   {
   17                           celsius = 5*(fahr - 32)/9;
   18                           cout << setw(10) << fahr << setw(10) << celsius
<< endl;
   19                           fahr = fahr + step;
Use list to display the source code from line 15 to line 19. 
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) list 15,19
   15           while (fahr <= upper)
   16                   {
   17                           celsius = 5*(fahr - 32)/9;
   18                           cout << setw(10) << fahr << setw(10) << celsius
<< endl;
   19                           fahr = fahr + step;
The program seems to stop too soon. We will set a breakpoint at the loop. 
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) stop at 15
(2) stop at "example1.cpp":15
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) run
Running: example1
(process id 112903)
      fahr   celsius
stopped in main at line 15 in file "example1.cpp"
   15           while (fahr <= upper)
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 17 in file "example1.cpp"
   17                           celsius = 5*(fahr - 32)/9;
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 18 in file "example1.cpp"
   18                           cout << setw(10) << fahr << setw(10) << celsius
<< endl;
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
         0       -17
stopped in main at line 19 in file "example1.cpp"
   19                           fahr = fahr + step;
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 15 in file "example1.cpp"
   15           while (fahr <= upper)
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 21 in file "example1.cpp"
   21           return 0;
That's strange. The program only ran for one loop then exited.
Let's print out the values of the variables and take a look. 
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) print fahr
fahr = 20
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) print upper
upper = 10
Oops! upper = 10?  
There is a typo because the variable "upper" was supposed to be set to 100 
instead of setting to 10.  We often have bugs that are very simple but are 
overlooked. DBX gives us an advantage by providing us with clues to the puzzle.  
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) quit
hercules[10]%

Example 2:

This program demonstrates how to manipulate values in an array.

#include<iostream>
using namespace std;

int main ()
{
     const int MAX_ARRAY = 10;
     int  numbers[MAX_ARRAY];
     int  index;
     int  sum;

    // Stored values in the array.
    for (index = 0; index < MAX_ARRAY; index++)
        {
        numbers[index] = index * index;
        cout << "numbers[" << index << "]=" << numbers[index] << endl;
        }

    // The values in the array are summed.
    sum = 0;
    for (index = 0; index <= 1000; index++)
        {
        sum = sum + numbers[index];
        }
    cout  << "Sum is "  << sum  << endl;

    return 0;
}

hercules[18]% CC -g example2.cpp -o example2
hercules[19]%
hercules[19]%
hercules[19]% example2
numbers[0]=0
numbers[1]=1
numbers[2]=4
numbers[3]=9
numbers[4]=16
numbers[5]=25
numbers[6]=36
numbers[7]=49
numbers[8]=64
numbers[9]=81
Segmentation fault (core dumped)
hercules[20]%

hercules[21]% dbx example2
changes (topic)
The major new features of this release relative to 6.0 are:

o The dbx environment variable "cfront_demangling" has been removed.
  The "-F" option to dbx (allow cfront-demangling) has also been removed.
  Use an earlier version of dbx to get cfront support.
o This release continues to support Fortran intrinsics on Intel, even
  though the Intel Fortran compiler was not shipped with WorkShop 6.
  The next dbx release will not support Fortran intrinsics on Intel.

See also `help changes60'


To suppress this message, add the following line to your .dbxrc file:

        dbxenv suppress_startup_message 5.0
Reading example2
Reading ld.so.1
Reading libCrun.so.1
Reading libm.so.1
Reading libw.so.1
Reading libc.so.1
Reading libdl.so.1
Reading libc_psr.so.1
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx)list
    6        const int MAX_ARRAY = 10;
    7        int  numbers[MAX_ARRAY];
    8        int  index;
    9        int  sum;
   10
   11       // Stored values in the array.
   12       for (index = 0; index < MAX_ARRAY; index++)
   13           {
   14           numbers[index] = index * index;
   15           cout << "numbers[" << index << "]=" << numbers[index] << endl;
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) list
   16           }
   17
   18       // The values in the array are summed.
   19       sum = 0;
   20       for (index = 0; index <= 1000; index++)
   21           {
   22           sum = sum + numbers[index];
   23           }
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) list
   24       cout  << "Sum is "  << sum  << endl;
   25
   26       return 0;
   27   }
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx)stop at 19
(2) stop at "example2.cpp":19
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) run
Running: example2
(process id 211921)
numbers[0]=0
numbers[1]=1
numbers[2]=4
numbers[3]=9
numbers[4]=16
numbers[5]=25
numbers[6]=36
numbers[7]=49
numbers[8]=64
numbers[9]=81
stopped in main at line 19 in file "example2.cpp"
   19       sum = 0;
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 20 in file "example2.cpp"
   20       for (index = 0; index <= 1000; index++)
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 22 in file "example2.cpp"
   22           sum = sum + numbers[index];
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 22 in file "example2.cpp"
   22           sum = sum + numbers[index];
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 22 in file "example2.cpp"
   22           sum = sum + numbers[index];
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 22 in file "example2.cpp"
   22           sum = sum + numbers[index];
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) next
stopped in main at line 22 in file "example2.cpp"
   22           sum = sum + numbers[index];
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) status
 (2) stop at "example2.cpp":19
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) dump
index = 4
sum = 14
MAX_ARRAY = 10
numbers = ARRAY
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx)trace sum
			.
			.
			.
			.
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx)cont
			.
			.
			.
			.
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) where
=>[1] main(), line 22 in "example2.cpp"
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx)quit

Here is another way to use the dbx to debug the same program example2.cpp:

hercules[27]% dbx example2
changes (topic)
The major new features of this release relative to 6.0 are:

o The dbx environment variable "cfront_demangling" has been removed.
  The "-F" option to dbx (allow cfront-demangling) has also been removed.
  Use an earlier version of dbx to get cfront support.
o This release continues to support Fortran intrinsics on Intel, even
  though the Intel Fortran compiler was not shipped with WorkShop 6.
  The next dbx release will not support Fortran intrinsics on Intel.

See also `help changes60'


To suppress this message, add the following line to your .dbxrc file:

        dbxenv suppress_startup_message 5.0
Reading example2
Reading ld.so.1
Reading libCrun.so.1
Reading libm.so.1
Reading libw.so.1
Reading libc.so.1
Reading libdl.so.1
Reading libc_psr.so.1
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) run
Running: example2
(process id 213194)
numbers[0]=0
numbers[1]=1
numbers[2]=4
numbers[3]=9
numbers[4]=16
numbers[5]=25
numbers[6]=36
numbers[7]=49
numbers[8]=64
numbers[9]=81
signal SEGV (no mapping at the fault address) in main at line 22 in file "exampl
e2.cpp"
   22           sum = sum + numbers[index];
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) list 20, 27
   20       for (index = 0; index <= 1000; index++)
   21           {
   22           sum = sum + numbers[index];
   23           }
   24       cout  << "Sum is "  << sum  << endl;
   25
   26       return 0;
   27   }
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) where
=>[1] main(), line 22 in "example2.cpp"
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) print index
index = 520
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) print sum
sum = 1741044306
(/opt/SUNWspro/bin/../WS6U1/bin/sparcv9/dbx) quit

Summary

Through this tutorial, you have learned the basic procedure for using 
the dbx debugger.  There is no in-lab exercise to be marked this week.
We hope you will find the dbx debugger helpful in debugging programs 
for your class assignments and for in future classes.

For more information on dbx, you can check out the references listed below.

References

• Unix man pages by typing man dbx
• Using dbx with C++
• Using dbx
• dbx User's Guide
• The dbx Source Code Debugger

Back to Highlights

This page last modified: Friday, 18-Nov-2005 15:17:22 CST

Accessed     times.

CS Dept Home Page

CS Dept Class Files

CS110-130 Class Files