RealView Debugger

Now...a fully integrated environment

The RealView Debugger product (RVD) is a debugger for all available ARM processors. It works with an ICE unit or a debug monitor on the target (Angel). It includes the following:

RVD is available for Windows, Solaris, and Linux.

Functional and Easy to Use

13a

RVD is a huge leap forward in debugging on ARM processors. It is easy to use, but is designed for engineers, with many powerful features.

The RVD GUI is very smooth, with carefully designed windows and operation. Context-sensitive menus are used throughout, and many windows have their own special window to provide access to commonly-used features. Operations like single stepping and very fast and the GUI aims to let you work as quickly as you like without holding you up.

GUI commands (such as setting a breakpoint with the mouse) are queued into an internal engine and executed in turn. This allows you to queue several operations to occur when the processor next stops, for example, which can save time. All GUI commands have a command-line equivalent which is displayed on the command line at the bottom of the screen. These commands can be logged and replayed, which can be handy for automatically bring the board to the same state each time in order to trap a nasty bug.

RVD has great breakpoint support, from simply setting a breakpoint at the cursor, to specifying complex breakpoint options and conditions.

Browsers are available for variables, files and functions. Registers can be viewed in hex, decimal and with various forward widths and options. It is easy to view memory at a particular register's address - just right-click the register and select the option from the menu. Windows can be updated by double clicking with the right button, or even automatically on a timer  - great for watching I/O regions.

RVD provides support for viewing I/O registers on common Integrator boards, and even allows you to define your own boards and chips for what ARM calls 'extended target visibility'. The memory map can be set to tell RVD how to access various areas of memory, and which areas are out of bounds.

Code can be edited in the debugging window - handy for when you spot a bug and want to quickly fix it. RVD can build your project, add/delete files from it and generate makefiles for you. It can even use your existing makefiles, provided you follow certain rules (and provide a few standard targets).

ARM's plan is for RVD was to allow you to see into every part of your system with the same consistent interface, whether it is the core registers, DSP registers, memory, source code, RTOS objects or trace data. RVD v1.7 delivers this for a selection of DSPs and RTOSs, and more will follow with time.

RVD will also load images from other tools in ELF format. For example it will load a Linux kernel (vmlinux), although with version 1.6 we have had problems getting it to reliably locate the source code for source-level debugging. Version 1.7 seems to fix these problems.

Multi-Core and Mixed Architecture

RVD takes the hassle out of debugging an ARM+DSP chip, at least provided the DSP is one of those supported by RVD. RVD can control both of these at the same time, i.e. simultaneous multi-core debugging.

Some chips even have more than one ARM core, and RVD supports debugging of these in the same GUI environment as well.

So what does it mean to debug more than one core at the same time?

  • Synchronous stopping of all cores when a breakpoint is hit on one of them. This allows the whole system to be examined without any state being lost
  • Each core can be independently single stepped and stopped. Breakpoints can be set and cleared on each core, with a unified GUI.

RVD improves productivity by allowing development of different parts of the system to occur in parallel. For example, you could develop a message passing protocol between an ARM and a DSP by alternatively writing and debugging code in each processor. Bugs which crop up in either processor can be quickly fixed. Problems which require a complex setup to repeat can be handled by logging the commands from the GUI into a file, and replaying the file each time after resetting the system.

OS Aware Debugging

RVD supports OS Aware debugging. Basically this means you can look at your RTOS resources and data structures, and set breakpoints at the process/task level rather than the system level.

RVD can display various of useful resources, including Threads, Processes, Libraries, Semaphores, Timers, Event Flags and queues.

Popular RTOSs ATI Nucleus and ThreadX are supported at present. Others will follow, with Symbian OS high on the list. RTOS vendors supply an OS Abstraction library for RVD which you can connect up to allow RVD to see inside your RTOS.

Extended Target Visibility

Do you wish your debugger could decode memory-mapped peripheral registers and display them in human-readable format, rather than just as numbers? RVD can do this, decoding bit fields and displaying values according to a configuration file you supply.

ARM supplies configuration files for common Integrator boards, so if you are using an Integrator platform RVD provides this functionality out of the box.

With this feature RVD can also handle programming of flash memory automatically. Simply load a program or file into the region of memory which is flash and RVD will automatically program the flash for you.

Trace & Analysis

With RealView ICE (or MultiTrace) you can capture a historical trace of instructions and data accesses in real time, without affecting the target. RVD allows you to view this information within the same GUI environment as your other debugging activities. Profiling views show you where your system is spending its time.

rvd.ht1

You can set simple 'trace points' simply by right-clicking in the code window - you can even select regions of code to be traced with the mouse. More complex trace facilities are accessed through dialogues.

Command Line and Scripting

Every operation you initiate in the RVD GUI has an equivalent on the command line and RVD displays it as you click. It also provides a command line entry line, so you can type commands if you like. Sometimes it is faster to type a command like 'break do_fft' rather than browsing for the do_fft function and setting a breakpoint.

Also, commands can be logged to a file. This file can then be used as a script to repeat the commands again. This is useful when you take a large number of steps to get your program to a particular stage which you need to repeat again and again. Redoing all those steps with the GUI would be painful - running a script takes seconds.

RealMonitor

13b

RealMonitor allows you to debug foreground tasks while interrupt tasks continue to run. This does not happen with the usual RealView ICE or Multi-ICE usage. RealMonitor works by putting a small program on the target (under 2 KB in size) which communicates with the host computer using the Debug Communications Channel. It still uses the ICE unit to transfer the data, but does not force the core into debug mode (thus halting execution) when communication takes place.

Breakpoints in the foreground application cause an exception which is handled by the RealMonitor program rather than the ICE unit. Since interrupts are still enabled and the core is running, interrupt tasks continue to operate. The foreground task can be stepped or continued and memory can read and written. You can also set and clear breakpoints.

RealMonitor also supports reading and writing of memory while the target is running. To do this, the controller forces a processor exception, jumping into the RealMonitor program to handle the request.

RealMonitor is great for changing variables to test adjustments without having to stop the processor, for example in motor control applications where stopping the processor might cause a component malfunction.

RealMonitor makes use of the EmbeddedICE-RT logic present in newer ARM cores. For those which don't have these, RealMonitor can still operate provided your code is in RAM. If the code being debugged is in ROM, then you need to have a core with EmbeddedICE-RT to allow RealMonitor to work.

Add-on Components

RVD is sold as a base product with a number of add-on components. Once you have the base product you can add any of the following features simply by purchasing a license for it:

  • Multi-core debug
  • DSPGroup Oak/TeakLite Debug
  • AXYS OakDSP SuperSim ISS
 

Applications

rs1

rs_2

rs_3

rs_4