TotalView Users Guide - CI Wiki

Watching Memory
Using Watchpoints
A watchpoint tracks a memory location—it does not track a variable. This
means that a watchpoint might not perform as you would expect it to when
watching stack or automatic variables. For example, suppose that you want
to watch a variable in a subroutine. When control exits from the subroutine,
the memory allocated on the stack for this subroutine is deallocated.
At this time, TotalView is watching unallocated stack memory. When the
stack memory is reallocated to a new stack frame, TotalView is still watching
this same position. This means that TotalView triggers the watchpoint
when something changes this newly allocated memory.
Also, if your program reinvokes a subroutine, it usually executes in a different
stack location. TotalView cannot monitor changes to the variable
because it is at a different memory location.
All of this means that in most circumstances, you shouldn’t place a watchpoint
on a stack variable. If you need to watch a stack variable, you will
need to create and delete the watchpoint each time your program invokes
the subroutine.
This doesn’t mean you can’t place a watchpoint on a stack or heap variable.
It just means that what happens is undefined after this memory is released.
For example, after you enter a routine, you can be assured that memory
locations are always tracked accurately until the memory is released.
In some circumstances, a subroutine may be called from the same location. This means
that its local variables might be in the same location. So, you might want to try.
If you place a watchpoint on a global or static variable that is always
accessed by reference (that is, the value of a variable is always accessed
using a pointer to the variable), you can set a watchpoint on it because the
memory locations used by the variable are not changing.
Triggering Watchpoints
When a watchpoint triggers, the thread’s program counter (PC) points to
the instruction following the instruction that caused the watchpoint to trigger.
If the memory store instruction is the last instruction in a source statement,
the PC points to the source line following the statement that triggered
the watchpoint. (Breakpoints and watchpoints work differently. A breakpoint
stops before an instruction executes. In contrast, a watchpoint stops
after an instruction executes.)
Using Multiple Watchpoints
If a program modifies more than one byte with one program instruction or
statement, which is normally the case when storing a word, TotalView triggers
the watchpoint with the lowest memory location in the modified region.
Although the program might be modifying locations monitored by other
watchpoints, TotalView only triggers the watchpoint for the lowest memory
TotalView Users Guide: version 8.7 377