You copied the Doc URL to your clipboard.

8 Viewing variables and data

The Variables Window contains two tabs that provide different ways to list your variables. The Locals tab contains all the variables for the current stack frame, while the Current Line(s) tab displays all the variables referenced on the currently selected lines. Please note that several compilers and libraries (such as Cray Fortran, OpenMP and others) generate extra code, including variables that are visible in Arm DDT's windows.

Right-clicking in these windows brings up additional options, including the ability to edit values (in the Evaluations window), to change the display base, or to compare data across processes and threads. The right-click menu also allows you to choose whether the fields in structures (classes or derived types) should be displayed alphabetically by element name or not, which is useful for when structures have very many different fields.

PIC

Figure 56: Displaying Variables

8.1 Sparklines

Numerical values may have sparklines displayed next to them. A sparkline is a line graph of process rank or thread index against value of the related expression. The exact behavior is determined by the focus control. See section Focus control.

If focussed on process groups, then process ranks are used. Otherwise, thread indices are used. The graph is bound by the minimum and maximum values found, or in the case that all values are equal the line is drawn across the vertical center of the highlighted region. Erroneous values such as Nan and Inf are represented as red, vertical bars. If focus is on process groups, then clicking on a sparkline displays the Cross-Process Comparison window for closer analysis. Otherwise, clicking on a sparkline displays the Cross-Thread Comparison window.

8.2 Current line

You can select a single line by clicking on it in the code viewer, or multiple lines by clicking and dragging. The variables are displayed in a tree view so that user-defined classes or structures can be expanded to view the variables contained within them. You can drag a variable from this window into the Evaluate Window. It is then evaluated in whichever stack frame, thread or process you select.

8.3 Local variables

The Locals tab contains local variables for the current process's currently active thread and stack frame.

For Fortran codes the amount of data reported as local can be substantial, as this can include many global or common block arrays. Should this prove problematic, it is best to conceal this tab underneath the Current Line(s) tab, as this will not then update after every step.

It is worth noting that variables defined within common blocks may not appear in the local variables tab with some compilers, this is because they are considered to be global variables when defined in a common memory space.

The Locals view compares the value of scalar variables against other processes. If a value varies across processes in the current group the value is highlighted in green.

When stepping or switching processes if the value of a variable is different from the previous position or process it is highlighted in blue.

After stepping out of function the return value is displayed at the top of the Locals view (for selected debuggers).

8.4 Arbitrary expressions and global variables

PIC

Figure 57: Evaluating Expressions

Since the global variables and arbitrary expressions do not get displayed with the local variables, you may wish to use the Current Line(s) tab in the Variables window and click on the line in the Source Code Viewer containing a reference to the global variable.

Alternatively, the Evaluate panel can be used to view the value of any arbitrary expression. Right-click on the Evaluate window, click on Add Expression, and type in the expression required in the current source file language. This value of the expression is displayed for the current process and stack/thread, and is updated after every step.

Note

At the time of writing Arm DDT does not apply the usual rules of precedence to logical Fortran expressions, such as x .ge. 32 .and. x .le. 45.. For now, please bracket such expressions thoroughly: (x .ge. 32) .and. (x .le. 45).

Note

Although the Fortran syntax allows you to use keywords as variable names, Arm DDT is not be able to evaluate such variables on most platforms. Please contact Arm support at Arm supportif this is a problem for you.

Expressions containing function calls are only evaluated for the current process/thread and sparklines are not displayed for those expressions, because of possible side effects caused by calling functions. Use Cross-Process or Cross-Thread Comparison for functions instead. See section Cross-process and cross-thread comparison.

8.4.1 Fortran intrinsics

The following Fortran intrinsics are supported by the default GNU debugger included with Arm DDT:

ABS AIMAG CEILING CMPLX
FLOOR IEEE_IS_FINITE IEEE_IS_INF IEEE_IS_NAN
IEEE_IS_NORMAL ISFINITE ISINF ISNAN
ISNORMAL MOD MODULO REALPART

Support in other debuggers, including the CUDA debugger variants, may vary.

8.4.2 Changing the language of an expression

Ordinarily, expressions in the Evaluate window and Locals/Current windows are evaluated in the language of the current stack frame. This may not always be appropriate. For example, a pointer to user defined structure may be passed as value within a Fortran section of code, and you may wish to view the fields of the C structure. Alternatively, you may wish to view a global value in a C++ class while your process is in a Fortran subroutine.

You can change the language that Arm DDT uses for your expressions by right-clicking on the expression, and clicking Change Type/Language, selecting the appropriate language for the expression. To restore the default behavior, change this back to Auto.

8.4.3 Macros and #defined constants

By default, many compilers do not output sufficient information to allow the debugger to display the values of "#defined" constants or macros, as including this information can greatly increase executable sizes.

With the GNU compiler, adding the "-g3" option to the command line options generates extra definition information which Arm DDT will then be able to display.

8.5 Help with Fortran modules

An executable containing Fortran modules presents a special set of problems for developers:

  • If there are many modules, each of which contains many procedures and variables (each of which can have the same name as something else in a separate Fortran module), keeping track of which name refers to which entity can become difficult.
  • When the Locals or Current Line(s) tabs (within the Variables window) display one of these variables, to which Fortran module does the variable belong?
  • How do you refer to a particular module variable in the Evaluate window?
  • How do you quickly jump to the source code for a particular Fortran module procedure?

To help with this, Arm DDT provides a Fortran Modules tab in the Project Navigator window.

When Arm DDT begins a session, Fortran module membership is automatically found from the information compiled into the executable.

A list of Fortran modules found is displayed in a simple tree view within the Fortran Modules tab of the Project Navigator window.

Each of these modules can be 'expanded' (by clicking on the + symbol to the left of the module name) to display the list of member procedures, member variables and the current values of those member variables.

Clicking on one of the displayed procedure names causes the Source Code Viewer to jump to that procedure's location in the source code. In addition, the return type of the procedure is displayed at the bottom of the Fortran Modules tab. Fortran subroutines will have a return type of VOID ().

Similarly, clicking on one of the displayed variable names causes the type of that variable to be displayed at the bottom of the Fortran Modules tab.

A module variable can be dragged and dropped into the Evaluate window. Here, all of the usual Evaluate window functionality applies to the module variable. To help with variable identification in the Evaluate window, module variable names are prefixed with the Fortran module name and two colons ::.

Right-clicking within the Fortran Modules tab brings up a context menu. For variables, choices on this menu includes sending the variable to the Evaluate window, the Multi-Dimensional Array Viewer and the Cross-Process Comparison Viewer.

Some caveats apply to the information displayed within the Fortran Modules tab:

  1. The Fortran Modules tab is not displayed if the underlying debugger does not support the retrieval and manipulation of Fortran module data.
  2. The Fortran Modules tab displays an empty module list if the Fortran modules debug data is not present or in a format understood by Arm DDT.

One limitation of the Fortran Modules tab is that the modules debug data compiled into the executable does not include any indication of the module USE hierarchy. For example, if module A USEs module B, the inherited members of module B are not shown under the data displayed for module A. Consequently, the Fortran Modules tab shows the module USE hierarchy in a flattened form, one level deep.

8.6 Viewing complex numbers in Fortran

When working with complex numbers, you may wish to view only the real or imaginary elements of the number. This can be useful when evaluating expressions, or viewing an array in the Multi-Dimensional Array Viewer See section Multi-dimensional array viewer (MDA).

You can use the Fortran intrinsic functions REALPART and AIMAG to get the real or imaginary parts of a number, or their C99 counterparts creal and cimag.

Complex numbers in Fortran can also be accessed as an array, where element 1 is the real part, and element 2 is the imaginary part.

PIC

Figure 58: Viewing the Fortran complex number 3+4i

8.7 C++ STL support

Arm DDT uses pretty printers for the GNU C++ STL implementation (versions 4.7 and greater), Nokia's Qt library, and Boost, designed for use with the GNU Debugger. These are used automatically to present such C++ data in a more understandable format.

For some compilers, the STL pretty printing can be confused by non-standard implementations of STL types used by a compiler's own STL implementation. In this case, and in the case where you wish to see the underlying implementation of an STL type, you can disable pretty printing by running DDT with the environment variable setting ALLINEA_DISABLE_PRETTY_PRINT=1.

Expanding elements in std::map, including unordered and multimap variants, is not supported when using object keys or pointer values.

8.8 Custom pretty printers

In addition to the pre-installed pretty printers you may also use your own GDB pretty printers.

A GDB pretty printer consists of an auto-load script that is automatically loaded when a particular executable or shared object is loaded and the actual pretty printer Python classes themselves. To make a pretty printer available in DDT copy it to ~/.allinea/gdb.

8.8.1 Example

An example pretty printer may be found in {installation-directory}/examples.

Compile the fruit example program using the GNU C++ compiler as follows:


cd {installation-directory}/examples 
make -f fruit.makefile

Now start Arm DDT with the example program as follows:


ddt --start {installation-directory}/examples/fruit
                                                                                       
                                                                                       

After the program has started right-click on line 20 and click the Run to here menu item. Click on the Locals tab and notice that the internal variable of myFruit are displayed.

Now install the fruit pretty printer by copying the files to ~/.allinea/gdb as follows:


cp -r {installation-directory}/examples/fruit-pretty-printer/* ∼/.allinea/gdb/

Re-run the program in Arm DDT and run to line 20, as before. Click on the Locals tab and notice that now, instead of the internal variable of myFruit, the type of fruit is displayed instead.

8.9 Viewing array data

Fortran users may find that it is not possible to view the upper bounds of an array. This is due to a lack of information from the compiler. In these circumstances Arm DDT displays the array with a size of 0, or simply <unknown_bounds>. It is still possible to view the contents of the array using the Evaluate window to view array(1), array(2), and so on, as separate entries.

To tell Arm DDT the size of the array right-click on the array and select the Edit Type… menu option. This opens a window similar to the one below. Enter the real type of the array in the New Type box.

PIC

Figure 59: Edit Type window

Alternatively the MDA can be used to view the entire array.

8.10 UPC support

Arm DDT supports many different UPC compilers, including the GNU UPC compiler, the Berkeley UPC compiler and those provided by Cray.

Note

In order to enable UPC support, you may need to select the appropriate MPI/UPC implementation from DDT's Options/System menu. See Section UPC

Debugging UPC applications introduces a small number of changes to the user interface.

  • Processes will be identified as UPC Threads, this is purely a terminology change for consistency with the UPC language terminology. UPC Threads will have behavior identical to that of separate processes: groups, process control and cross-process data comparison for example will apply across UPC Threads.
  • The type qualifier shared is given for shared arrays or pointers to shared.
  • Shared pointers are printed as a triple (address, thread, phase). For indefinitely blocked pointers the phase is omitted.
  • Referencing shared items will yield a shared pointer and pointer arithmetic may be performed on shared pointers.
  • Dereferencing a shared pointer (for example, dereferencing *(&x[n] + 1])) will correctly evaluate and fetch remote data where required.
  • Values in shared arrays are not automatically compared across processes: the value of x[i] is by definition identical across all processes. It is not possible to identify pending read/write to remote data. Non-shared data types such as local data or local array elements will still be compared automatically.
  • Distributed arrays are handled implicitly by the debugger. There is no need to use the explicit distributed dimensions feature in the MDA.

All other components of Arm DDT will be identical to debugging any multi-process code.

8.11 Changing data values

In the Evaluate window, the value of an expression may be set by right-clicking and selecting Edit Value. This allows you to change the value of the expression for the current process, current group, or for all processes.

Note

The variable must exist in the current stack frame for each process you wish to assign the value to.

8.12 Viewing numbers in different bases

When you are viewing an integer numerical expression you may right-click on the value and use the View As sub menu to change which base the value is displayed in. The View As → Default option displays the value in its original (default) base.

8.13 Examining pointers

You can examine pointer contents by clicking the + next to the variable or expression. This expands the item and dereference the pointer.

In the Evaluate window, you can also use the View As Vector, Get Address, and Dereference Pointer menu items. Dereference Pointer wraps the expression in *(). Get Address strips a single layer of *() from the expression (if one exists). Both Get Address and Dereference Pointer currently only support raw pointers and not other pointer implementations, such as, C++11 smart pointers.

See also Multi-dimensional array viewer (MDA) .

8.14 Multi-dimensional arrays in the Variable View

When viewing a multi-dimensional array in either the Locals, Current Line(s) or Evaluate windows it is possible to expand the array to view the contents of each cell.

In C/C++ the array expands from left to right, x, y, z will be seen with the x column first, then under each x cell a y column, whereas in Fortran the opposite will be seen with arrays being displayed from right to left as you read it so x, y, z would have z as the first column with y under each z cell.

The first thousand elements in an array are shown in the Locals or Current Line(s) view. Larger arrays are truncated, but elements after the first thousand can be viewed by evaluating an expression or using the multi-dimensional array viewer.

PIC

Figure 60: 2D Array in C: type of array is int[4][3]

PIC

Figure 61: 2D Array in Fortran: type of twodee is integer(3,5)

8.15 Multi-dimensional array viewer (MDA)

Arm DDT provides a Multi-Dimensional Array (MDA) Viewer (fig. ) for viewing multi-dimensional arrays.

To open the Multi-Dimensional Array Viewer, right-click on a variable in the Source Code, Locals, Current Line(s) or Evaluate views and select the View Array (MDA) context menu option. You can also open the MDA directly by selecting the Multi-Dimensional Array Viewer menu item from the View menu.

PIC

Figure 62: Multi-Dimensional Array Viewer

If you open the MDA by right clicking on a variable, Arm DDT will automatically set the Array Expression and other parameters based on the type of the variable. Click the Evaluate button to see the contents of the array in the Data Table.

The Full Window button hides the settings at the top of the window so the table of values occupies the full window, allowing you to make full use of your screen space. Click the button again to reveal the settings.

8.15.1 Array expression

The Array Expression is an expression containing a number of subscript metavariables that are substituted with the subscripts of the array. For example, the expression myArray($i, $j) has two metavariables, $i and $j. The metavariables are unrelated to the variables in your program.

The range of each metavariable is defined in the boxes below the expression, for example Range of $i. The Array Expression is evaluated for each combination of $i, $j, and so on, and the results shown in the Data Table. You can also control whether each metavariable is shown in the Data Table using Rows or Columns.

By default, the ranges for these metavariables are integer constants entered using spin boxes. However, the MDA also supports specifying these ranges as expressions in terms of program variables. These expressions are then evaluated in the debugger. To allow the entry of these expressions, check the Staggered Array check box. This will convert all the range entry fields from spin boxes to line edits allowing the entry of freeform text.

The metavariables may be reordered by dragging and dropping them. For C/C++ expressions the major dimension is on the left and the minor dimension on the right, for Fortran expressions the major dimension is on the right and the minor dimension on the left. Distributed dimensions may not be reordered, they must always be the most major dimensions.

8.15.2 Filtering by value

You may want the Data Table to only show elements that fit a certain criteria, for example elements that are zero.

If the Only show if box is checked then only elements that match the boolean expression in the box are displayed in the Data Table, for example, $value == 0. The special metavariable $value in the expression is replaced by the actual value of each element. The Data Table automatically hides rows or columns in the table where no elements match the expression.

Any valid expression for the current language may be used here, including references to variables in scope and function calls. You may want to be careful to avoid functions with side effects as these will be evaluated many times over.

8.15.3 Distributed arrays

A distributed array is an array that is distributed across one or more processes as local arrays.

The Multi-Dimensional Array Viewer can display certain types of distributed arrays, namely UPC shared arrays (for supported UPC implementations), and general arrays where the distributed dimensions are the most major, that is, the distributed dimensions change the most slowly, and are independent from the non-distributed dimensions.

UPC shared arrays are treated the same as local arrays, simply right-click on the array variable and select View Array (MDA).

To view a non-UPC distributed array first create a process group containing all the processes that the array is distributed over.

If the array is distributed over all processes in your job then you can simply select the All group instead. Right-click on the local array variable in the Source Code, Locals, Current Line(s) or Evaluate views.

The Multi-Dimensional Array Viewer window will open with the Array Expression already filled in.

Enter the number of distributed array dimensions in the corresponding box. A new subscript metavariable (such as $p, $q) will be automatically added for each distributed dimension.

Enter the ranges of the distributed dimensions so that the product is equal to the number of processes in the current process group, then click the Evaluate button.

8.15.4 Advanced: how arrays are laid out in the data table

The Data Table is two dimensional, but the Multi-Dimensional Array Viewer may be used to view arrays with any number of dimensions, as the name implies. This section describes how multi-dimensional arrays are displayed in the two dimensional table.

Each subscript metavariable (such as $i, $j, $p, $q) maps to a separate dimension on a hypercube. Usually the number of metavariables is equal to the number of dimensions in a given array, but this does not necessarily need to be the case. For example myArray($i, $j) * $k introduces an extra dimension, $k, as well as the two dimensions corresponding to the two dimensions of myArray.

The figure below corresponds to the expression myArray($i, $j) with $i = 0..3 and $j = 0..4.

PIC

Figure 63: myArray($i, $j) with $i = 0..3 and $j = 0..4.

If, by way of example, imagine that myArray is part of a three dimensional array distributed across three processes. The figure below shows what the local arrays look like for each process.

PIC

Figure 64: The local array myArray($i, $j) with $i = 0..3 and $j = 0..4 on ranks 0-2

And as a three dimensional distributed array with $p the distributed dimension:

PIC

Figure 65: A three dimensional distributed array comprised of the local array myArray($i, $j) with $i = 0..3 and $j = 0..4 on ranks 0-2 with $p the distributed dimension

This cube is projected (just like 3D projection) onto the two dimensional Data Table. Dimensions marked Display as Rows are shown in rows, and dimensions marked Display as Columns are shown in columns, as you would expect.

More than one dimension may viewed as Rows, or more than one dimension viewed as Columns.

The dimension that changes fastest depends on the language your program is written in. For C/C++ programs the leftmost metavariable (usually $i for local arrays or $p for distributed arrays) changes the most slowly (just like with C array subscripts). The rightmost dimension changes the most quickly. For Fortran programs the order is reversed, that is the rightmost is most major, the leftmost most minor.

The figure below shows how the three dimensional distributed array above is projected onto the two dimensional Data Table:

PIC

Figure 66: A three dimensional distributed array comprised of the local array myArray($i, $j) with $i = 0..3 and $j = 0..4 on ranks 0-2 projected onto the Data Table with $p (the distributed dimension) and $j displayed as Columns and $i displayed as Rows.

8.15.5 Auto Update

If you check the Auto Update check box the Data Table will be automatically updated as you switch between processes/threads and step through the code.

8.15.6 Comparing elements across processes

When viewing an array in the Data Table, you may double-click or choose Compare Element Across Processes from the context menu for a particular element.

This displays the Cross-Process Comparison dialog for the specified element.

See Cross-process and cross-thread comparison for more information.

8.15.7 Statistics

The Statistics tab displays information which may be of interest, such as the range of the values in the table, and the number of special numerical values, such as nan or inf.

8.15.8 Export

You may export the contents of the results table to a file in the Comma Separated Values (CSV) or HDF5 format that can be plotted or analysed in your favourite spreadsheet or mathematics program.

There are two CSV export options: List (one row per value) and Table (same layout as the on screen table).

Note

If you export a Fortran array from Arm DDT in HDF5 format the contents of the array are written in column major order. This is the order expected by most Fortran code, but the arrays will be transposed if read with the default settings by C-based HDF5 tools. Most HDF5 tools have an option to switch between row major and column major order.

8.15.9 Visualization

If your system is OpenGL-capable then a 2-D slice of an array, or table of expressions, may be displayed as a surface in 3-D space through the Multi-Dimensional Array (MDA) Viewer.

You can only plot one or two dimensions at a time. If your table has more than two dimensions the Visualise button will be disabled.

After filling the table of the MDA Viewer with values (see previous section), click Visualise to open a 3-D view of the surface.

To display surfaces from two or more different processes on the same plot simply select another process in the main process group window and click Evaluate in the MDA window, and when the values are ready, click Visualise again.

The surfaces displayed on the graph may be hidden and shown using the check boxes on the right-hand side of the window.

The graph may be moved and rotated using the mouse and a number of extra options are available from the window toolbar.

The mouse controls are:

  • Hold down the left button and drag the mouse to rotate the graph.
  • Hold down the right button to zoom. Drag the mouse forwards to zoom in and backwards to zoom out.
  • Hold the middle button and drag the mouse to move the graph.

Note

Arm DDT requires OpenGL to run. If your machine does not have hardware OpenGL support, software emulation libraries such as MesaGL are also supported.

Note

In some configurations OpenGL is known to crash. A work-around if the 3D visualization crashes is to set the environment variable LIBGL_ALWAYS_INDIRECT to 1. The precise configuration which triggers this problem is not known.

PIC

Figure 67: DDT Visualization

The toolbar and menu offer options to configure lighting and other effects, including the ability to save an image of the surface as it currently appears. There is even a stereo vision mode that works with red-blue glasses to give a convincing impression of depth and form. Contact Arm support if you need to obtain some 3D glasses.

8.16 Cross-process and cross-thread comparison

The Cross-Process Comparison and Cross-Thread Comparison windows can be used to analyze expressions calculated on each of the processes in the current process group. Each window displays information in three ways: raw comparison, statistically, and graphically.

This is a more detailed view than the sparklines that are automatically drawn against a variable in the evaluations and locals/current line windows for multi-process sessions.

To compare values across processes or threads, right-click on a variable inside the Source Code, Locals, Current Line(s) or Evaluate windows and then choose one of the View Across Processes (CPC) or View Across Threads (CTC) options. You can also bring up the CPC or CTC directly from the View menu in the main menu bar. Alternatively, clicking on a sparkline will bring up the CPC if focus is on process groups and the CTC otherwise.

PIC

Figure 68: Cross-Process Comparison-Compare View

Processes and threads are grouped by expression value when using the raw comparison. The precision of this grouping can be specified (for floating point values) by filling the Limit box.

If you are comparing across processes, you can turn each of these groupings of processes into a Arm DDT process group by clicking the create groups button. This creates several process groups, one for each line in the panel. Using this capability large process groups can be managed with simple expressions to create groups. These expressions are any valid expression in the present language (that is, C/C++/Fortran).

For threaded applications, when using the CTC, if Arm DDT is able to identify OpenMP thread IDs, a third column will also display the corresponding OpenMP thread IDs for each thread that has each value. The value displayed in this third column for any non-OpenMP threads that are running depends on your compiler but is typically -1 or 0. OpenMP thread IDs should be available when using Intel and PGI compilers provided compiler optimisations have not removed the required information (recompile with -O0 if necessary). OpenMP thread IDs can only be obtained from GCC compiled programs if the compiler itself was compiled with TLS enabled, unfortunately this is not the case for the packaged GCC installs on any of the major Linux distributions at time of writing (Redhat 7, SUSE 12 or Ubuntu 16.04). The display of OpenMP thread IDs is not currently supported when using the Cray compiler or the IBM XLC/XLF compilers.

You can enter a second boolean expression in the Only show if box to control which values are displayed. Only values for which the boolean expression evaluates to true / .TRUE. are displayed in the results table. The special metavariable $value in the expression is replaced by the actual value. Click the Show Examples link to see examples.

The Align Stack Frames check box tries to automatically make sure all processes and threads are in the same stack frame when comparing the variable value. This is very helpful for most programs, but you may wish to disable it if different processes/threads run entirely different programs.

The Use as MPI Rank button is described in the next section, Assigning MPI Ranks.

You can create a group for the ranks corresponding to each unique value by clicking the Create Groups button.

The Export button allows you to export the list of values and corresponding ranks as a Comma Separated Values (CSV) file.

The Full Window button hides the settings at the top of the window so the list of values occupies the full window, allowing you to make full use of your screen space. Click the button again to reveal the settings again.

The Statistics panel shows Maximum, Minimum, Variance and other statistics for numerical values.

8.17 Assigning MPI ranks

Sometimes, Arm DDT cannot detect the MPI rank for each of your processes. This might be because you are using an experimental MPI version, or because you have attached to a running program, or only part of a running program. Whatever the reason, it is easy to tell DDT what each process should be called.

To begin, choose a variable that holds the MPI world rank for each process, or an expression that calculates it. Use the Cross-Process Comparison window to evaluate the expression across all the processes. If the variable is valid, the Use as MPI Rank button will be enabled. Click it, Arm DDT immediately relabels all of its processes with these new values.

What makes a variable or expression valid? These criteria must be met:

  1. It must be an integer.
  2. Every process must have a unique number afterwards.

These are the only restrictions. As you can see, there is no need to use the MPI rank if you have an alternate numbering scheme that makes more sense in your application. In fact you can relabel only a few of the processes and not all, if you prefer, so long as afterwards every process still has a unique number.

8.18 Viewing registers

To view the values of machine registers on the currently selected process, select the Registers window from the View pull-down menu. These values will be updated after each instruction, change in thread or change in stack frame.

PIC

Figure 69: Register View

8.19 Process details

To view the process details dialog select the Process Details menu item from the Tools menu. Details can be sorted by any columns, in ascending or descending order.

PIC

Figure 70: Process Details

8.20 Disassembler

To view the disassembly (assembly instructions) of a function select the Disassemble menu item from the Tools menu. By default you will see the disassembly of the current function, but you can view the disassembly of another function by entering the function name in the box at the top and clicking the Disassemble button.

PIC

Figure 71: Disassemble Tool

8.21 Interacting directly with the debugger

PIC

Figure 72: Raw Command Window

Arm DDT provides a Raw Command window that allows you to send commands directly to the debugger interface. This window bypasses DDT and its book-keeping. If you set a breakpoint here, Arm DDT will not list this in the breakpoint list.

Be careful with this window. It is recommended you only use it where the graphical interface does not provide the information or control you require. Sending commands such as quit or kill may cause the interface to stop responding to Arm DDT.

Each command is sent to the current group or process depending on the current focus. If the current group or process is running, Arm DDT prompts you to pause the group or process first.

Was this page helpful? Yes No