Inspect Manual

Using Inspect on a TNS/R System
Inspect Manual—429164-006
15-5
General TNS/R Debugging Considerations
General TNS/R Debugging Considerations
These considerations apply when debugging non-accelerated, accelerated, and native
programs on a TNS/R machine.

Data breakpoints
Data breakpoints might be reported at different locations than on a TNS system.

Data representation
Data is represented the same as on TNS systems. Data pointer values and stack
frames are the same. The one exception is 32-bit code pointers, such as extended
pointers to P-relative arrays, which might have different values on a TNS/R system
due to differences in the extended addressing of code. References through such
pointers will yield the same results as on TNS systems.

System Global Space
TNS/R systems differ in how they handle nonprivileged references to the System
Global (SG) space. TNS systems redirect such references to the user data space,
whereas a trap is reported on a TNS/R machine.
When performing nonprivileged debugging on a TNS/R processor, Inspect reports
an error if a System Global address is specified.

Address Wrap
The TNS and TNS/R systems differ in how they handle data stack addresses that
overflow 16 bits. TNS systems discard the high-order bits, in effect wrapping the
address to the beginning of the data stack. A trap is reported if this occurs on a
TNS/R machine.
Debugging Non-Accelerated Programs
Debugging non-accelerated programs on a TNS/R processor is nearly identical to
debugging them on a TNS system. The only difference is in the area of data
breakpoints, which may be reported at slightly different locations than on a TNS
machine. You can debug non-accelerated programs both at the source level and at
the TNS machine level.
Debugging Accelerated Programs
When debugging accelerated programs, there are minor restrictions when you debug
at the source level and significant restrictions when you debug at the TNS machine
level. Limited debugging is available at the TNS/R machine level.
Inspect supports the existing TNS model of debugging for accelerated programs,
subject to certain constraints. Source-level debugging is least affected by these
constraints, while TNS machine-level debugging is significantly limited. This TNS view
of an accelerated program may be inconsistent at some locations because: