User Tips

22

This chapter includes the following tips:


Using dbx Equivalents for Common GDB Commands	page 233
Reviewing dbx Changes	page 235
Enabling Command-Line Editing	page 237
Being In Scope	page 238
Locating Files	page 238
Enabling Command-Line Editing	page 238
Locating Floating-Point Exceptions with dbx	page 240
Using dbx with Multithreaded Programs	page 241

Using `dbx` Equivalents for Common `GDB` Commands

The following table lists approximate equivalent dbx commands for some common GNU Debugging (GDB) commands:


`GDB`	`DBX`
`break` line	`stop at` line
`break` func	`stop in` func
`break` *addr	`stopi at` addr
`break ... if` expr	`stop ... -if` expr
`cond` n	`stop ... -if` expr
`tbreak`	`stop ... -temp`
`watch` expr	`stop` expr `[slow]`
`watch` var	`stop modify` &var `[fast]`
`catch` x	`intercept` x
`info break`	`status`
`info watch`	`status`
`clear`	`clear`
`clear` fun	`delete` n
`delete`	`delete all`
`disable`	`handler -disable all`
`disable` n	`handler -disable` n
`enable`	`handler -enable all`
`enable` n	`handler -enable` n
`ignore` n cnt	`handler -count` n cnt
`commands` n	`when ... { cmds; }`
`backtrace` n	`where n`
`frame` n	`frame n`
`info reg` reg	`print` $reg
`finish`	`step up`
`signal` num	`cont sig` num
`jump` line	`cont at` line
`set` var`=`expr	`assign` var`=`expr
`x/`fmt addr	`x` addr`/`fmt
`disassem` addr	`dis` addr
`shell` cmd	`sh` cmd `[if needed]`
`info func` regex	`funcs` regexp
`ptype` type	`whatis -t` type
`define cmd`	`function cmd`
`handle` sig	`stop sig` sig
`info signals`	`status; catch`
`attach` pid	`debug -` pid
`attach` pid	`debug a.out` pid
`file` file	`[unnecessary]`
`exec` file	`debug` file
`core` file	`debug` a.out corefile
`set editing on`	`set -o emacs`
`set language` x	`language` x
`set prompt` x	`PS1=`x
`set history size` x	`HISTSIZE=`x
`set print object on`	`dbxenv output_dynamic_type on`
`show commands`	`history`
`dir` name	`pathmap` name
`show dir`	`pathmap`
`info line <`n	`listi` n
`info source`	`file`
`info sources`	`files; modules`
`forw` regex	`search` regexp
`rev` regex	`bsearch` regexp

Reviewing `dbx` Changes

Using the `.dbxinit` File

Long-time users of dbx might be using the .dbxinit file instead of the newer .dbxrc file. If you have a .dbxrc file, dbx reads it and ignores any .dbxinit file present. If necessary, you can get dbx to read both by adding the following lines to your .dbxrc file:


`kalias alias=dalias` `source ~/.dbxinit` `kalias alias=kalias`

If you don't have a .dbxrc file, but do have a .dbxinit file, you should see the warning message:

Using .dbxinit compatibility mode. See \Qhelp .dbxrc' for more information.

Using .dbxinit compatibility mode. See \Qhelp .dbxrc' for more information.

Currently, dbx still reads your .dbxinit file. although this feature may disappear in a future release.

If you still use a dbxinit file, review Chapter 13, "Customizing dbx" for information about using the .dbxrc file instead.

Alias Definition

The alias command is now a pre-defined alias for dalias or kalias.

The Symbols `/` and `?`

With the introduction of a KornShell-based parser, the / (forward slash) command had to be renamed because it cannot be distinguished from a UNIX pathname. Use search instead.

This example

(dbx) /abc

(dbx) `/abc`

now means to execute the file abc from the root directory.

This example reads expand the pattern that matches all files in the current directory with a four-character filename having abc as the last three characters, then execute the resulting command.

(dbx)?abc

(dbx)`?abc`

If you use these commands frequently, you may wish to create aliases for them:

alias ff=search

find forward

alias fb=bsearch

find backward

`alias ff=search`	find forward
`alias fb=bsearch`	find backward

Embedded Slash Command

The embedded slash command was renamed. This is no longer valid:


0x1234/5X

Use the examine command or its alias, x:

examine 0x1234/5X

x 0x1234/5X

examine 0x1234/5X x 0x1234/5X

Using `assign` Instead of `set`

set is now the KornShell set command, and is no longer an alias for assign.

Enabling Command-Line Editing

You can enable command-line editing in several ways. First, if $FCEDIT, $EDITOR, or $VISUAL is set, its value is checked. If the last component, the component after the last slash, contains the string emacs, then emacs-mode is enabled. If it contains vi, vi-mode is enabled. If none of the three environment variables are set or if the first one in the list that is set does not contain emacs or vi, then command-line editing is disabled.

You can enable emacs mode or vi mode from the command line or in your .dbxrc file:

set -o emacs

set -o vi

`set -o emacs` `set -o vi`

To disable command-line editing,:

set +o emacs +o vi

`set +o emacs +o vi`

Being In Scope

If dbx claims that abc is not defined in the current scope, it means that no symbol named abc is accessible from the current point of execution. See Chapter 3, "Viewing and Visiting Code" for details.

Locating Files

All files created by dbx are placed in the directory /top unless the environment variable TMPDIR is set, in which case the directory $TMPDIR is used.

If your source files are not where they were when they were compiled, or if you compiled on a different machine than you are debugging on and the compile directory is not mounted as the same pathname, dbx cannot find them. See the pathmap command in Chapter 2, "Starting dbx" for a solution.

Reaching Breakpoints

If you do not reach the breakpoint you expected to reach, consider the following possibilities:

If you've placed a breakpoint on a function, it might not be the function you think. Use whereis funcname to find out how many functions of a given name exist. Then use the exact syntax as presented by the output of whereis in your stop command.

If the breakpoint is on a while loop, the compiler logically converts code of the following form to:


while (condition) statement

if (condition) {

again:

statement

if condition

goto again;

}

if (condition) { again: statement if condition goto again; }

In this situation, the breakpoint you put on the while amounts to putting a breakpoint only on the outer if, because dbx cannot deal with source lines that map to two or more different addresses.

C++ member and `whatis` Command

Sometimes the type of a C++ member is missing in the output of whatis. In the following example, the type of member stackcount is missing:


(dbx) whatis stack class stack { ... static stackcount; /* Never defined or allocated */ ... };

When a class member is not defined or allocated, dbx cannot determine its type so there is no type to print.

Runtime Checking 8Megabyte Limit

Only access checking has this limit. Leak checking is not affected by this limit.

For access checking, RTC replaces each load and store instruction with a branch instruction that branches to a patch area. This branch instruction has an 8Mb range. If the debugged program has used up all the address space within 8Mb of the particular load/store instruction being replaced, there is no place to put the patch area. If RTC can't intercept ALL loads and stores to memory it cannot provide accurate information and so disables access checking completely.

dbx internally applies some strategies when it runs into this limitation and continues if it can rectify this problem. In some cases dbx cannot proceed; it turns off access checking after printing an error message. For workarounds, see Chapter 9, "Using Runtime Checking."

Locating Floating-Point Exceptions with `dbx`

You need to do two things. First, to stop the process whenever an FP exception occurs, type:


(dbx) `catch FPE`

Next, add the following to your Fortran application:

integer ieeer, ieee_handler, myhandler

ieeer = ieee_handler('set', 'all', myhandler)

...

integer function myhandler(sig, code, context)

integer sig, code(5)

call abort()

end

integer ieeer, ieee_handler, myhandler ieeer = ieee_handler('set', 'all', myhandler) ... integer function myhandler(sig, code, context) integer sig, code(5) call abort() end

This is necessary because the ieee software typically sets all errors to be silent (not raising signals). This causes all ieee exceptions to generate a SIGFPE as appropriate, which is probably too much.

You can further tailor which exceptions you see by adjusting the parameters of ieee_handler() or by using an alternative to the dbx catch command:

stop sig FPE

stop sig FPE

which acts just like catch FPE, or

stop sig FPE subcode

stop sig FPE subcode

For finer control, subcode can be one of the following:

FPE_INTDIV

1

integer divide by zero

FPE_INTOVF

2

integer overflow

FPE_FLTDIV

3

floating point divide by zero

FPE_FLTOVF

4

floating point overflow

FPE_FLTUND

5

floating point underflow

FPE_FLTRES

6

floating point inexact result

FPE_FLTINV

7

invalid floating point operation

FPE_FLTSUB

8

subscript out of range

FPE_INTDIV	1	integer divide by zero
FPE_INTOVF	2	integer overflow
FPE_FLTDIV	3	floating point divide by zero
FPE_FLTOVF	4	floating point overflow
FPE_FLTUND	5	floating point underflow
FPE_FLTRES	6	floating point inexact result
FPE_FLTINV	7	invalid floating point operation
FPE_FLTSUB	8	subscript out of range