In general, dbx recognizes most expression operators from C, Fortran 77, and Pascal. dbx also provides some of its own operators. Operators follow the C language precedence. You can also use parentheses to explicitly determine the order of evaluation.

The following list describes the operators provided by dbx.

The # operator takes the line number specified by the expression that follows it and returns the address of that source line. If you precede the # operator with a filename enclosed in quotation marks, the # operator returns the address of the line number in the file you specify. If you precede the # operator with the name of a procedure, dbx identifies the source file that contains the procedure and returns the address of the line number in that file.

A pound sign (#) introduces a comment in a dbx script file. When dbx sees a pound sign in a script file, it interprets all characters between the pound sign and the end of the current line as a comment. See “Executing dbx Scripts” in Chapter 4, for more information on dbx script files. To include the # operator in a dbx script, use two pound signs (for example, ##27).

(dbx) print #27

(dbx) print "foo.c"   #27

(dbx) print bar #27

The following list shows the C language operators recognized by dbx:

---

Note: C does not allow the use of the sizeof operator on bit fields. However, dbx allows you to enter expressions using the sizeof operator on bit fields; in these cases, dbx returns the number of bytes in the data type of bit fields (such as int or unsigned int). The C language exclusive-OR (^) operator is not supported. Use the dbx xor operator instead.

---

The following list describes the Pascal operators recognized by dbx:

The following list describes the FORTRAN 77 and Fortran 90 language operators recognized by dbx. Note that dbx does not recognize Fortran logical operators (such as .or. and .TRUE.).

Fortran array subscripts may be in either square brackets, [ ], or the standard parenthesis, ( ), and the Fortran 90 member selection operator (%) is allowed.

You can use both numeric and string constants under dbx. Expressions cannot contain constants defined by #define declarations to the C preprocessor.

Values printed by the print command as well as values returned by the ccall command can be saved so they can be displayed later or used in other expressions.

Use the following command to enable this feature:

% set $printhistory=0

The value variables are created with names starting with $, followed by a number and displayed after each print and ccall command. These values can be later referred to by using the generated name. The last value can also be referred to simply as $.

(dbx) set $valuehistory=1
(dbx) print foof()
$1 = 9.9899997711181641
(dbx) print $1/4567.98987
$2 = 0.0021869575142289366
(dbx) print $
$3 = 0.0021869575142289366

You can access the value of a variable only while it is in scope. The variable is in scope only if the block or procedure with which it is associated is active.

After you start your program, whenever your program executes a block or procedure that contains variables, your program allocates space for those variables and they “come into scope.” You may access the values of those variables as long as the block or procedure is active. Once the block or procedure ends, the space for those variables is deallocated and you may no longer access their values.

You can display the value of a program variable by using the printd, printf, printo, and printx commands and the pd, po, and px aliases described in “Printing Expressions”.

(dbx) print total
235

(dbx) print message
"Press <Return> to continue."

(dbx) print array

{
    [0] struct list {
        next = (nil)
        value = 1034
    }
    [1] struct list {
        next = 0x10012258
        value = 1031
    }
    [2] struct list {
        next = 0x10012270
        value = 1028
    }
    [3] struct list {
        next = 0x10012288
        value = 1025
    }
    [4] struct list {
        next = 0x100122a0
        value = 1022
    }
    [5] struct list {
        next = 0x100122b8
        value = 1019
    }
...
}

(dbx) print array[5]
struct list {
    next = 0x100122b8
    value = 1019
}

(dbx) &float_vals[4] / 6f
10012018:  0.25000000000000000 0.20000000298023224 0.16666699945926666
0.14280000329017639
10012028:  0.12500000000000000 0.11111100018024445

The assign command changes the value of existing program variables. You can also use the assign command to change the value of machine registers, as described in “Changing Register Values” in Chapter 7.

The following is the syntax of the assign command:

assign variable=expression

This command assigns the value of expression to the program variable.

(dbx) assign x = 27
27
(dbx) assign y = 37.5
37.5

(dbx) assign *(int *) (&next) = 0
0
(dbx) assign next = 0
(nil)
(dbx) assign next = (struct list*) 0;
(nil)

When naming variables in your program, avoid using any dbx keywords. If you have a variable with the same name as a dbx keyword and you attempt to use that variable in a dbx command, dbx reports a syntax error.

If you do have a program variable with the same name as a dbx command, you can force dbx to treat it as a variable by enclosing the variable in parentheses.

dbx keywords include:

all    not
and    or
at     pgrp
div    pid
if     sizeof
in     to
mod    xor

(dbx) print in
print in
     ^ syntax error
Suggestion: in is a dbx keyword; a revised command is in history.
Type !16 or !! to execute: print (in)

(dbx) print (in)
34

Whether dbx is case sensitive when it evaluates program variable names depends on the value of the dbx $casesense variable.

If $casesense is 2 (the default), then the language in which the variable was defined is taken into account (for example, C and C++ are case sensitive while Pascal and Fortran are not). If $casesense is 1, case is always checked. If $casesense is 0, case is always ignored. Note that file (module) names are always case sensitive since they represent UNIX file names.

The duel language is implemented by adding the duel command to dbx. All dbx commands work as before. The duel command, however, is interpreted by duel, and its concepts are not understood by other dbx commands.

---

Note: This version of duel does not allow interactive function calls.

---

duel is based on expressions that return multiple values. The x..y operator returns the integers from x to y; the x,y operator returns x and then y.

(dbx) duel (1,9,12..15,22)

(dbx) duel x[1,9,12..15,22]   

The semicolon (;) prevents duel output. duel aliases are defined with x:=y and provide an alternative to variable declaration. You can also return x[i] instead of using printf:

(dbx) duel if(x[i:=0..99]<0) x[i]
x[i] = -4

(dbx) duel if(x[i:=0..99]<0) x[{i}]
x[7] = -4

(dbx) duel x[..100] <? 0
x[7] = -4

duel's x.y and x->y allow an expression y, evaluated under x's scope:

(dbx) duel emp[..100].(if(code>400) (code,name))
emp[46].code = 682
emp[46].name = “Ela”

The if() expression is evaluated under the scope of each element of emp[], an array of structures. In C language terms, we have to write:

for(i = 0; i < 100; i++ ) {
  if(emp[1].code > 400) {
    printf(“%d %s\n”,emp[i].cond,emp[i].name);

(dbx) ..100 => if(emp[_].code>400) emp[_].code,emp[_].name   

(dbx) duel head-->next->data   
head->data = 12
head->next->data = 14
head-->next[[2]]->data = 20
head-->next[[3]]->data = 26

(dbx) duel head-->next[[50..60]]->data   

(dbx) duel #/( head-->next->data >? 50 )   

Most duel operators have the same precedence as their C counterparts. Table 5-2, lists duel operators in decreasing precedence.

Table 5-3, lists and briefly explains duel examples.

The duel semantics are modeled after the Icon programming language. The input consists of expressions that return sequences of values. C statements are cast as expressions, too. Expressions are parsed into abstract syntax trees, which are traversed during evaluation. The evaluation of most nodes (operators) recursively evaluates the next value for each operand, and then applies the operator to produce the next result. Only one value is produced each time, and duel's eval function keeps a state record for each node (backtracking, co-routines, consumer-producer or threads are good metaphors for the evaluation mechanism).

For example, in (5,3)+6..8, the evaluation of + first retrieves the operands 5 and 6, to compute and return 5+6. Then 7, the next right operand is retrieved and 5+7 is returned, followed by 5+8. Since no other right operand value exists, the next left operand, 3 is fetched. The right operand's computation is restarted returning 6, and 3+6 is returned. The final return values are 3+7 and 3+8.

The computation for operators like x>?y is similar, but when x<=y, the next values are fetched instead of returning a value, forming the basis for an implicit search. Operators like .. return a sequence of values for each pair of operands.

The duel values follow the C semantics. A value is either an lvalue (can be used as the left-hand side of assignment), or an rvalue. Therefor, objects like arrays can not be directly manipulated. However, operators like x..y can accomplish such tasks.

The duel types also follow the C semantics, with some important differences. C types are checked statically; duel types are checked when operators are applied. For example, (1,1.0)/2 returns 0 (int) and 0.5 (double); (x,y).z returns x.z and y.z even if x and y are of different types, as long as they both have a field z.

Values and types of symbols are looked up at run-time (using the dbx lookup rules).

To avoid this ambiguity, the keyword T must precede a user-defined type. For example, if value is a typedef, C's (value (*)()) x is written in duel as (T value (*)()) x. Types that begin with a reserved keyword don't need T. For example, (struct value*) x and (long *[5]) y are accepted. As special cases, (type)x and (type*)x are accepted but discouraged (it causes (printf)(“hi”), which is valid in C, to fail). A side effect is that sizeof x must be written as sizeof(x).

The duel operators are described in the following list:

x=y x+y x-y x*y x/y x%y x^y x|y x&y x<<y x>>y

x>y x<y x>=y x<=y x==y x!=y x[y]
	These binary operators follow their C semantics. For each value of x, they are evaluated for every value of y. For example, (5,2)>(4,1) evaluates as 5>4, 5>1, 2>4, 2>1 returning 1, 1, 0, 1. The y values are reevaluated for each new value of x. For example, i=4; (4,5)>i++ evaluates as 4>4 and 5>5. Beware of multiple y values in assignment. For example, x[..3]=(4,6,9) does not set x[0]=4, x[1]=6, and x[2]=9. It assigns 4, 6, and 9 to each element, which has the same effect as x[..3]=9. Use x[i:=..3]=(4,6,9)[[i]] to achieve the desired effect.
-x ~x &x *x !x ++x --x x++ x-- sizeof(x) (type)x
	These unary operators follow their C semantics. They are applied to each value of x. The increment and decrement operators require an lvalue, so i:=0 ; i++ produces an error because i is a duel alias to 0, an rvalue. Parenthesis must be used with sizeof(x). Note that sizeof x is not allowed. Cast to user defined type requires generally requires T. For example, (T val(*)())x, but (val)x and (val*)x are accepted as special cases.
x&&y x||y
	These logical operators also follow their C semantics, but have nonintuitive results for multi-valued x and y. For example, (1,0,0) || (1,0) returns 1,1,0,1,0 - the right hand-side (1,0) is returned for each left-hand side 0. It is best to use these operators only in single value expressions.
x? y:z if(x)y if(x)y else z
	These expressions return the values of y for each nonzero value returned by x, and the values of z for each zero value returned by x. For example, if(x[..100]==0) y returns y for every x[i]==0, not if all x[i] are zero (if(&&/(x[..100]==0)); y does that). Also, if(x) y; else z is illegal. duel's semicolon is an expression separator, not a terminator.
while(x)y for(w;x;y)z
	The while(x)y expression returns y as long as all values of x are nonzero. The for() expression is similar and both have the expected C semantics. For example, for(i=0 ; i<100 ; i++) x[i] is the same as x[..100]. Unlike the if() expression, while(x[..100]==0) continues to execute only if all elements of x are zero, that is, the condition is evaluated into a single value using an implicit &&/x. At present, assignments are not supported, so the for is of limited utility except to assign aliases.
x,y x..y ..x x..
	These operators produce multiple values for single value operands. x,y returns x, then y. x..y returns the integers from x to y. When x>y, the sequence is returned in descending order, that is, 5..3 returns 5, 4, 3. The ..x operator is a shorthand for 0..x-1. For example, ..3 returns 0, 1, 2. The x.. operator is a shorthand for x..maxint. It returns increasing integer values starting at x indefinitely, and should be bounded by [[n]] or @n operators. A comma (,) retains its precedence level in C. The precedence of .. is above < and below arithmetic operators, so 0..n-1 and x==1..9 work as expected.
x,,y
	The ,, operator is very low precedence, is only usable inside the [] array operators, and is used to separate the dimension expressions of Fortran multi-dimensional arrays. Note the deviation from Fortran and dbx command-line usage; array operators are square brackets, [ ], not parentheses, ( ).
x<?y x>?y x>=?y x<=?y x!=?y x==?y
	These operators work like their C counterparts but return x if the comparison is true. If the comparison is false, the next (x,y) value is tried, forming the basis of an implicit search.
(x) {x} x;y x=>y
	Both () and {} act as C parenthesis. The {} set the returned symbolic value as the actual value. For example, if i=5 and x[5]=3, then x[i] produces the output x[i] = 3, x[{i}] produces x[5] = 3, and {x[i]} produces 3. The semicolon is an operator. x;y evaluates x, ignoring the results, then evaluates and returns y. For example, (i:=1..3 ; i+5) sets i to 3 and returns 8. The x=>y operator evaluates and returns y for each value of x. For example, (i:=1..3 => i+5) returns 6, 7, and 8. The value returned by x is also stored implicitly in _, which can be used in y. For example, 1..5 => z[_][_] produces z[1][1], z[2][2], and so forth. The symbolic value for _ is that of the left side value, hence {_} is not needed. Semicolon (;) has the lowest precedence, so it must be used inside () or {} for compound expressions. The precedence of => is just below comma (,). Be aware that if(a) x; else {y;} z is illegal; a semicolon is not allowed before } or else and must be inserted before z.
x->y x.y
	These expressions work as in C for a symbol y. If y is an expression, it is evaluated under the scope of x. For example, x.(a+b) is the same as x.a+x.b, if a and b are fields of x (if they are not, they are looked up as local or global variables). x may return multiple values of different types. For example, (u,v).a returns u.a and v.a, even if u and v are different structures. Also, the value of x is available as _ inside y. For example, x[..100].(if(a) _) produces x[i] for each x[i].a!=0. Nested x.y are allowed. For example, u.(v.(a+b)) looks up a and b first under v, then under u.
x:=y
	The duel aliases store a reference to y in x. Any reference to x is then replaced by y. If y is a constant or an rvalue, its value is replaced for x. If y is an lvalue (e.g., a variable), a reference to same lvalue is returned. For example, x:=emp[5] ; x=9 assigns 9 to emp[5]. Aliases retain their values across invocation of the duel command. A duel alias to a local variable references a stray address when the variable goes out of scope. The special command duel clear delete all the duel aliases; duel alias shows all current duel aliases. Symbols are looked up as duel aliases first, so a duel alias x will hide a local x. The duel aliases are separate from dbx aliases. Currently, duel aliases are shared across all processes.
x-->y
	The expansion operator x-->y expands a data structure x following the y links. It returns x, x->y, x->y->y, until a null is found. If x is null, no values are produced. If y returns multiple values, they are stacked and each is further expanded in a depth-first notion. For example, if r is the root of a tree with children u->childs[..u->nchilds], then u-->(childs[..nchilds]) expands the whole tree. y is an arbitrary expression, evaluated exactly like x->y (this includes _).
x@y
	The expression x@y produces the values of x until x.y is nonzero. For example, for(i=0 ; x[i].code!= -1 && i<100 ; i++) x[i] can be written as x[..100]@(code==-1). The evaluation of x is stopped as soon as y evaluates to true. x->y (or x=>y) is used to evaluate y when x is not a struct or a union. If y is a constant, (_==y) is used. For example, s[0..]@0 produces the characters in string s up to but not including the terminating null.
#/x &&/x ||/x
	These operators return a single summary value for all the values returned by x. The #/x returns the number of values returned by x. For example, #/(x[..100]>?0) counts the number of positive x[i]. The &&/x returns 1 if all the values produced by x are nonzero, and ||/x returns 1 if any of x's values are nonzero. Like in C, the evaluation stops as soon as possible. For example, ||/(x[..100]==0) and &&/(x[..100]==0) check if one or all of x[i] are zero, respectively.
x#y x[[y]]
	The operator x#y produces the values of x and arranges for y to be an alias for the index of each value in x. It is commonly used with x-->y to produce the element's index. For example, head-->next->val#i=i assigns each val field its element number in the list. The selection operator x[[y]] produces the yth result of x. If y returns multiple value, each select a value of x. For example, (5,7,11,13)[3,0,2] returns 13, 5, and 11 (13 is the third element, 5 is the 0th element). Do not use side effects in x, since its evaluation can be restarted depending on y. For example, after (x[0..i++])[[3,5]] the value of i is unpredictable. Note: Within a duel command, the # operator does not have anything to do with line numbers or dbx comments.
frame(n) frames_no func.x
	The frame(n) for an integer n returns a reference to the nth frame, or activation level, on the stack (0 is the inner most function and frame(frames_no-1) is main()). Frame values can be compared to function pointers. For example, frame(3)==myfunc is true if the fourth frame is a call to myfunc, and in scope resolution. For example, frame(3).x returns the local variable x of the fourth frame. The frames_no is the number of active frames on the stack. For example, (frames(..frames_no) ==? myfunc).x displays x for all active invocations of myfunc. As a special case, (frames(..frames_no)==?f)[[0]].x can be written as f.x (x can be an expression).

The following list describes the differences between duel and the C, and Fortran languages.

The where command prints stack traces. Stack traces show the current activation levels (procedures) of a program.

(dbx) where
>  0 foo2(i = 5) [“/usr/var/tmp/dbx_examples/test.c”:44, 0x1000109c]
   1 foo(i = 4) [“/usr/var/tmp/dbx_examples/test.c”:38, 0x1000105c]
   2 main(argc = 1, argv = 0xffffffad78) [“/usr/var/tmp/dbx_examples/test.c”:55,
0x10001104]
   3 __start() [“/shamu/lib/libc/libc_64/crt1text.s”:137, 0x10000ee4]

If a program is highly recursive, stack traces can get quite long. The dbx $stacktracelimit variable controls the maximum number of activation levels that appear in a stack trace. In the example above, setting $stacktracelimit = 2 before issuing the where command reduces the set of reported frames to just levels 0 and 1.

(dbx) where
>  0 fooexample(0x300000000, 0x4000000ff, 0x5000000ff, 0x0)
[“/usr/var/tmp/dbx_examples/test3.c”:10, 0x10000cf8]
  1 main(0x3, 0x4, 0x5, 0x0) [“/usr/var/tmp/dbx_examples/test3.c”:5,
0x10000cbc]
  2 __start() [“/shamu/lib/libc/libc_64/csu/crt1text.s”:137,
0x10000c64]
(dbx) quit
Process 22582 terminated
int fooexample(int,int,int);
int main()
{
       fooexample(3,4,5);
       return 0;
}
int fooexample(int i, int j, int k)
{
       int x = i + j + 3*k;
       return x;
}

(dbx) where
> 0 subr1(0x3, 0x7fffaf14, 0x7fffaf1c, 0x0) [“t.c”:3, 0x4009ec]
  1 test(0x3, 0x7fffaf14, 0x7fffaf1c, 0x0) [“t.c”:8, 0x400a10]
  2 main(0x1, 0x7fffaf14, 0x7fffaf1c, 0x0) [“t.c”:13, 0x400a48]
  3 __start() [“crt1text.s”:133, 0x40099c]

(dbx) where
> 0 subr1(0x3, 0xffffffaed8, 0xffffffaee8, 0x0, 0x2f, 0x10, 0x0, 0xfbd82a0)
[“/usr/people/doc/debug/t.c”:3, 0x10000c9c]
  1 test(0x3, 0xffffffaed8, 0xffffffaee8, 0x0, 0x2f, 0x10, 0x0, 0xfbd82a0)
[“/usr/people/doc/debug/t.c”:9, 0x10000ce8]
  2 main(0x1000000ff, 0xffffffaed8, 0xffffffaee8, 0x0, 0x2f, 0x10, 0x0,
0xfbd82a0) [“/usr/people/doc/debug/t.c”:14, 0x10000d2c]
  3 __start() [“/shamu/redwood2/work/irix/lib/libc/libc_64/csu/crt1text.s”:137,
0x10000c70]

int test(void)
{
     subr1(3);
}

The up and down commands move up and down the activation levels in the stack. These commands are useful when examining a call from one level to another. You can also move up and down the activation stack with the func command described in “Moving to a Specified Procedure”.

The up and down commands each take num as an argument. up [num] moves up the specified number of activation levels in the stack. The default is one level. down [num] moves down the specified number of activation levels in the stack. The default is one level.

When you change activation levels, your scope changes. For example, unless you qualify a variable, as described in “Qualifying Names of Program Elements”, dbx assumes that variables you reference are local to the current activation level. Also, dbx changes the current source file to the file containing the procedure's source.

Consider examining the stack trace for a program called test4 and moving up in the activation stack:

(dbx) where
>  0 foo2(i = 5) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   1 foo(i = 4) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]
   2 main(argc = 1, argv = 0xffffffad78)
[“/usr/var/tmp/dbx_examples/test4.c”:25, 0x10000fa0]
   3 __start() [“/shamu/lib/libc/libc_64/csu/crt1text.s”:137, 0x10000f34]
(dbx) print i
5
(dbx) up 
foo:  40  r = foo2(i+1);

The current activation level is now the procedure foo. As indicated in the output, the variable i receives the argument passed to foo and is therefore local to foo. The variable i at this activation level is different from the variable i in the foo2 activation level. You can reference the currently active i as i; whereas you must qualify the reference to the i in foo2:

(dbx) print i
4
(dbx) print foo2.i
<symbol not found>

Moving up one more activation level brings you to the main procedure:

(dbx) up
main:  25  j = foo(j);
(dbx) file
/usr/var/tmp/dbx_examples/test4.c

In this example, the source for main is in test4.c, whereas the source for foo and foo2 is in foo.c; therefore, dbx changes the current source file when you move up to the main activation level.

dbx resets the source file when you return to the foo2 activation level:

(dbx) down 2
foo2:  46  printf(“foo2 arg is %d\n”,i);
(dbx) file
/usr/var/tmp/dbx_examples/foo.c

The func command moves you up or down the activation stack. You can specify the new activation level by providing either a procedure name or an activation level number.

The syntax for the func command is:

func [activation_level][procedure]

The following arguments are available:

When you change your activation level, your scope changes. For example, unless you qualify a variable as described in “Qualifying Names of Program Elements”, dbx assumes that variables you reference are local to the current activation level. Also, dbx changes the current source file to the one containing the procedure's source and the current line to the first line of the procedure.

You can also give the func command the name of a procedure that is not on the activation stack, even when your program is not executing. In this case, dbx has no corresponding activation level to make current. However, dbx still changes the current source file to the one containing the procedure's source and the current line to the first line of the procedure.

(dbx) where
>  0 foo2(i = 5) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   1 foo(i = 4) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]
   2 main(argc = 1, argv = 0xffffffad78)
[“/usr/var/tmp/dbx_examples/test4.c”:25, 0x10000fa0]
   3 __start() [“/shamu/lib/libc/libc_64/csu/crt1text.s”:137, 0x10000f34]

(dbx) func main
main:  25  j = foo(j);

If you use the func command to go to a function that is not on the activation stack, dbx changes only the current source file to the one containing the procedure's source and the current line to the first line of the procedure:

(dbx) func bar
   3  {
(dbx) file
/usr/var/tmp/dbx_examples/bar.c

The dump command prints information about the variables in an activation level. The following is the syntax for this command:

dump [procedure] [.]

The following arguments are available:

(dbx) dump
foo2(i = 5) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]

(dbx) dump main
main(argc = 1, argv = 0xffffffad78) [“/usr/var/tmp/dbx_examples/test4.c”:25,
0x10000fa0]
j = 4
i = 12
r = <expression or syntax error>
a = 0
total = 0

(dbx) dump .
>  0 foo2(i = 5) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   1 foo(i = 4) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]
r = 0
   2 main(argc = 1, argv = 0xffffffad78)
[“/usr/var/tmp/dbx_examples/test4.c”:25, 0x10000fa0]
j = 4
i = 12
r = <bad operand>
a = 0
total = 0

If your function does not return a value, or if you want to execute a function primarily for its side effects, you can execute the function interactively with the dbx command ccall. The following is the syntax for this command:

ccall func [arg1, arg2,... ,argn]

This command calls a function with the given arguments. Regardless of the language the function was written in, the call is interpreted as if it were written in C, and normal C calling conventions are used.

---

Note: Structure and union arguments to a function, and structure and union returns from a function, are not supported.

---

Functions called interactively honor breakpoints. Thus you can debug a function by setting breakpoints and then calling it interactively.

(dbx) where
>  0 foo2(i = 9) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   1 foo(i = 8) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]

===== interactive function call =====

   2 foo2(i = 5) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   3 foo(i = 4) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]
   4 main(argc = 1, argv = 0xffffffad78)
[“/usr/var/tmp/dbx_examples/test4.c”:25, 0x10000fa0]
   5 __start() [“/shamu/lib/libc/libc_64/csu/crt1text.s”:137, 0x10000f34]

If you stop execution of an interactively called function, you are responsible for eventually unstacking the call and returning from the function call. To unstack a call, you can complete the call using dbx commands such as cont, resume, next, or step as many times as necessary. If you run or rerun your program, dbx automatically unstacks all interactive function calls.

Another way to unstack an interactive function call is to execute the clearcalls command, which clears all stopped interactive calls.

(dbx) clearcalls

When stopped or faulted within one or more nested interactive calls, the clearcalls command removes these calls from the stack and returns the program to its regular callstack. This command is useful when a segmentation fault, infinite loop, or other fatal error is encountered within the interactive call.

When stopped in an interactive call, the call stack displayed by where shows the following line at the end of each stack of interactive call instantiation.

==== interactive function call ====

>  0 foo2(i = 9) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   1 foo(i = 8) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]

===== interactive function call =====

   2 foo2(i = 5) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   3 foo(i = 4) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]
   4 main(argc = 1, argv = 0xffffffad78)
[“/usr/var/tmp/dbx_examples/test4.c”:25, 0x10000fa0]
   5 __start() [“/shamu/lib/libc/libc_64/csu/crt1text.s”:137, 0x10000f34]

You can also nest interactive function calls. In other words, if you have one or more breakpoints in a function, and you call that function repeatedly, each interactive call is stacked on top of the previous call. Breakpoints in a function affect all nesting levels, so you cannot have different breakpoints at different nesting levels.

(dbx) where
>  0 foo2(i = 17) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   1 foo(i = 16) [“/usr/var/tmp/src/dbx_examples/foo.c”:40, 0x100011d4]

===== interactive function call =====

   2 foo2(i = 9) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   3 foo(i = 8) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]

===== interactive function call =====

   4 foo2(i = 5) [“/usr/var/tmp/dbx_examples/foo.c”:46, 0x10001214]
   5 foo(i = 4) [“/usr/var/tmp/dbx_examples/foo.c”:40, 0x100011d4]
   6 main(argc = 1, argv = 0xffffffad78)
[“/usr/var/tmp/src/dbx_examples/test4.c”:25, 0x10000fa0]
   7 __start() [“/shamu/lib/libc/libc_64/csu/crt1text.s”:137,
0x10000f34]

(dbx) stop in foo if j == 7
Process     0: [3] stop in foo if j==7