Event specifications are used by the stop command, stopi command, when command, wheni command, trace command, and tracei command to denote event types and parameters. The format consists of a keyword representing the event type and optional parameters. The meaning of an event specification is generally identical for all three commands. Exceptions are documented in the command descriptions in Appendix D.
A breakpoint is a location where an action occurs, at which point the program stops executing. This section describes event specifications for breakpoint events.
The syntax for the in event specification is:
in function
The function has been entered, and the first line is about to be executed. The first executable code after the prolog is used as the actual breakpoint location. This might be a line where a local variable is being initialized. In the case of C++ constructors, execution stops after all base class constructors have executed. If the –instr modifier is used, it is the first instruction of the function about to be executed. The function specification can take a formal parameter signature to help with overloaded function names or template instance specification. For example:
stop in mumble(int, float, struct Node *)
The syntax for the at event specification is:
at [filename:]line-number
The designated line is about to be executed. If you specify filename, then the designated line in the specified file is about to be executed. The file name can be the name of a source file or an object file. Although quotation marks are not required, they might be necessary if the file name contains special characters. If the designated line is in template code, a breakpoint is placed on all instances of that template.
You can also use specify a specific address:
at address-expression
The instruction at the given address is about to be executed. This event is available only with the stopi command or with the –instr event modifier.
The syntax for the infile event specification is:
infile filename
This event puts a breakpoint on every function defined in a file. The stop infile command iterates through the same list of functions as the funcs –f filename command.
Method definitions in .h files, template files, or plain C code in .h files, such as the kind used by the regexp command, might contribute function definitions to a file, but these definitions are excluded.
If the specified filename is the name of an object file (that is, it ends in .o). breakpoints are put on every function that occurs in that object file.
The stop infile list.h command does not put breakpoints on all instances of methods defined in the list.h file. Use events like inclass or inmethod to do so.
The fix command might eliminate or add a function to a file. The stop infile command puts breakpoints on all old versions of function in a file as well as any functions that might be added in the future.
No breakpoints are put on nested functions or subroutines in Fortran files.
You can use the clear command to disable a single breakpoint in the set created by the infile event.
The syntax for the infunction event specification is:
infunction function
This specification is equivalent to in function for all overloaded functions named function or all template instantiations thereof.
The syntax for the inmember event specification is:
inmember function
This specification is an alias for the inmethod event specification.
The syntax for the inmethod event specification is:
inmethod function
This specification is equivalent to the in function or the member method named function for every class.
The syntax for the inclass event specification is:
inclass classname [-recurse | -norecurse]
This specification is equivalent to in function for all member functions that are members of classname, but not any of the bases of classname. –norecurse is the default. If –recurse is specified, the base classes are included.
The syntax for the inobject event specification is:
inobject object-expression [-recurse | -norecurse]
A member function called on the specific object at the address denoted by object-expression has been called. stop inobject ox is roughly equivalent to the following, but unlike inclass, bases of the dynamic type of ox are included. –recurse is the default. If –norecurse is specified, the base classes are not included.
stop inclass dynamic_type(ox) -if this==ox
This section describes event specifications for events that involve access or change to the contents of a memory address.
The syntax for the access event specification is:
access mode address-expression [,byte-size-expression]
The memory specified by address-expression has been accessed.
mode specifies how the memory was accessed. Valid values are one or all of the following letters:
The memory at the specified address has been read.
The memory has been written to.
The memory has been executed.
mode can also contain either of the following:
Stops the process after the access (default).
Stops the process before the access.
In both cases the program counter will point at the offending instruction. The “before” and “after” refer to the side effect.
address-expression is any expression that can be evaluated to produce an address. If you provide a symbolic expression, the size of the region to be watched is automatically deduced. You can override it by specifying byte-size-expression. You can also use nonsymbolic, typeless address expressions, in which case, the size is mandatory. For example:
stop access w 0x5678, sizeof(Complex)
The access command has the limitation that no two matched regions can overlap.
The syntax for the change event specification is:
change variable
The value of variable has changed. The change event is roughly equivalent to:
when step { if [ $last_value !=$[variable]]
then
stop
else
last_value=$[variable]
fi
}
This event is implemented using single-stepping. For faster performance, use the access event.
The first time variable is checked causes one event, even though no change is detected. This first event provides access to the initial value of variable. Subsequent detected changes in the value of variable trigger additional events.
The syntax for the cond event specification is:
cond condition-expression
The condition denoted by condition-expression evaluates to true. You can specify any expression for condition-expression, but it must evaluate to an integral type. The cond event is roughly equivalent to the following stop command:
stop step -if conditional-expression
This section describes event specifications for system events.
The syntax for the dlopen() and dlopen() event specifications is:
dlopen [ lib-path ]
dlclose [ lib-path ]
System events occur after a dlopen() call or a dlclose() call succeeds. A dlopen() call or dlclose() call can cause more than one library to be loaded. The list of these libraries is always available in the predefined variable $dllist. The first shell word in $dllist is a + (plus sign) or a - (minus sign), indicating whether the list of libraries is being added or deleted.
lib-path is the name of a shared library. If it is specified, the event occurs only if the given library was loaded or unloaded. In that case, $dlobj contains the name of the library. $dllist is still available.
If lib-path begins with a /, a full string match is performed. Otherwise, only the tails of the paths are compared.
If lib-path is not specified, then the events always occur whenever there is any dl-activity. In this case, $dlobj is empty but $dllist is valid.
The syntax for the fault event specification is:
fault fault
The fault event occurs when the specified fault is encountered. The faults are architecture-dependent. The set of faults known to dbx is listed in the following list and defined in the proc(4) man page.
Illegal instruction
Privileged instruction
Breakpoint trap
Trace trap (single step)
Memory access (such as alignment)
Memory bounds (invalid address)
Integer overflow
Integer zero divide
Floating-point exception
Irrecoverable stack fault
Recoverable page fault
Watchpoint trap
CPU performance counter overflow
These faults are taken from /usr/include/sys/fault.h. fault can be any of those listed above, in uppercase or lowercase, with or without the FLT- prefix, or the actual numerical code.
The syntax for the lwp_exit event specification is:
lwp_exit
The lwp_exit event occurs when lwp has been exited. $lwp contains the ID of the exited LWP (lightweight process) for the duration of the event handler.
The syntax for the sig event specification is:
sig signal
The sig signal event occurs when the signal is first delivered to the program being debugged. signal can be either a decimal number or the signal name in uppercase or lowercase. The prefix is optional. This event is completely independent of the catch command and ignore command, although the catch command can be implemented as follows:
function simple_catch {
when sig $1 {
stop;
echo Stopped due to $sigstr $sig
whereami
}
}
Alternatively, you can specify a signal with a sub-code. The syntax for this option of the sig event specification is:
sig signal sub-code
When the specified signal with the specified sub-code is first delivered to the child, the sig signal sub-code event occurs. As with signals, you can provide the sub-code as a decimal number, in uppercase or lowercase. The prefix is optional.
The syntax for the sysin event specification is:
sysin code|name
The specified system call has just been initiated, and the process has entered kernel mode.
The concept of system call supported by dbx is that provided by traps into the kernel as enumerated in /usr/include/sys/syscall.h.
This concept is not the same as the ABI notion of system calls. Some ABI system calls are partially implemented in user mode and use non-ABI kernel traps. However, most of the generic system calls (the main exception being signal handling) are the same between syscall.h and the ABI.
The list of kernel system call traps in /usr/include/sys/syscall.h is part of a private interface in the Oracle Solaris OS that changes from release to release. The list of trap names (codes) and trap numbers that dbx accepts includes all of those supported by any of the versions of the Oracle Solaris OS that dbx supports. The names supported by dbx are unlikely to exactly match those of any particular release of the Oracle Solaris OS, and some of the names in syscall.h might not be available. Any trap number (code) is accepted by dbx and works as expected, but a warning is issued if it does not correspond to a known system call trap.
The syntax for the sysout event specification is:
sysout code|name
The specified system call is finished, and the process is about to return to user mode.
Without arguments, all system calls are traced. Certain dbx features, for example, the modify event and runtime checking, cause the child to execute system calls for its own purposes and show up if traced.
This section describes event specifications for events pertaining to execution progress.
The syntax for the exit event specification is:
exit exitcode
The exit event occurs when the process has exited.
The next event is similar to the step event except that functions are not stepped into.
The returns event is a breakpoint at the return point of the current visited function. The visited function is used so that you can use the returns event specification after giving a number of step up commands. The returns event is always –temp and can only be created in the presence of a live process.
The syntax for the returns event specification is:
returns function
The r eturns function event executes each time the given function returns to its call site. This is not a temporary event. The return value is not provided, but you can find integral return values by accessing the following registers:
SPARC based systems – $o0
x86 based systems – $eax
x64 based systems – $rax, $rdx
The event is roughly equivalent to:
when in func { stop returns; }
The step event occurs when the first instruction of a source line is executed. For example, you can get simple tracing with the following command:
when step { echo $lineno: $line; }; cont
When enabling a step event, you instruct dbx to single step automatically the next time cont command is used.
The syntax for the throw event is:
throw [type | –unhandled | –unexpected]
The throw event occurs whenever any exception that is not unhandled or unexpected is thrown by the application.
If an exception type is specified with the throw event, only exceptions of that type cause the throw event to occur.
If the –unhandled option is specified, a special exception type signifying an exception is thrown but for which there is no handler.
The –unexpected option is specified, a special exception type signifying an exception does not satisfy the exception specification of the function that threw it.
The following section describes event specifications for tracked threads.
The omp_barrier event specification is when the tracked thread enters or exits a barrier. You can specify a type, which can be explicit or implicit, and a state, which can be enter, exit, or all_entered. The default is explicit all_entered.
The omp_taskwait event specification is when the tracked thread enters or exists a taskwait. You can specify a state, which can be enter or exit. The default is exit.
The omp_ordered event specification is when the tracked thread enters or exists an ordered region. You can specify a state, which can be begin, enter or exit. The default is enter.
The omp_critical event specification is when the tracked thread enters a critical region.
The omp_atomic event specification is when the tracked thread enters or exists an atomic region. You can specify a state, which can be begin or exit. The default is begin.
The omp_flush event specification is when the tracked thread enters a explicit flush region.
The omp_task event specification is when the tracked thread enters or exists a task region. You can specify a state, which can be create, start or finish. The default is start.
The omp_master event specification is when the tracked thread enters a master region.
The omp_single event specification is when the tracked thread enters a single region.
This section describes event specifications for other types of events.
The attach event is when dbx has successfully attached to a process.
The detach event is when dbx has successfully detached from the program being debugged.
The lastrites event is when process being debugged is about to expire, which can happen for the following reasons:
The _exit(2) system call has been called, either through an explicit call or when main() returns.
A terminating signal is about to be delivered.
The process is being killed by the kill command.
The final state of the process is usually, but not always, available when this event is triggered, giving you your last opportunity to examine the state of the process. Resuming execution after this event terminates the process.
The proc_gone event occurs when dbx is no longer associated with a debugged process. The predefined variable $reason can be signal, exit, kill, or detach.
The prog_new event occurs when a new program has been loaded as a result of follow exec.
The stop event occurs whenever the process stops such that the user receives a prompt, particularly in response to a stop handler. For example, the following commands are equivalent:
display x
when stop {print x;}
The sync event occurs when the process being debugged has just been executed with exec(). All memory specified in a.out is valid and present, but preloaded shared libraries have not been loaded. For example, printf, although available to dbx, has not been mapped into memory.
A stop on this event is ineffective; however, you can use the sync event with the when command.
The syncrtld event occurs after a sync or an attach if the process being debugged has not yet processed shared libraries. It executes after the dynamic linker startup code has executed and the symbol tables of all preloaded shared libraries have been loaded but before any code in the .init section has run.
A stop on this event is ineffective; however, you can use the syncrtld event with the when command.
The thr_create event occurs when a thread, or a thread with the specified thread ID, has been created. For example, in the following stop command, the thread ID t@1 refers to creating thread, while the thread ID t@5 refers to the created thread.
stop thr_create t@5 -thread t@1
The thr_exit event occurs when a thread has exited. To capture the exit of a specific thread, use the -thread option of the stop command as follows:
stop thr_exit -thread t@5
The syntax for the timer event is:
timer seconds
The timer event occurs when the program being debugged has been running for seconds. The timer used with this event is shared with collector command. The resolution is in milliseconds, so a floating point value for seconds, for example 0.001, is acceptable.